| /******************************************************************************* |
| * Copyright (c) 2000, 2005 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.api; |
| |
| import java.util.ArrayList; |
| import java.util.Arrays; |
| import java.util.HashSet; |
| import java.util.List; |
| import java.util.Set; |
| |
| import org.eclipse.core.resources.IFile; |
| import org.eclipse.core.resources.IMarker; |
| import org.eclipse.core.resources.IProject; |
| import org.eclipse.core.resources.IResource; |
| import org.eclipse.core.runtime.IAdaptable; |
| import org.eclipse.jface.util.IPropertyChangeListener; |
| import org.eclipse.jface.util.PropertyChangeEvent; |
| import org.eclipse.ui.IEditorInput; |
| import org.eclipse.ui.IEditorPart; |
| import org.eclipse.ui.IEditorReference; |
| import org.eclipse.ui.IMemento; |
| import org.eclipse.ui.IPageLayout; |
| import org.eclipse.ui.IPerspectiveDescriptor; |
| import org.eclipse.ui.IPerspectiveRegistry; |
| import org.eclipse.ui.IViewPart; |
| import org.eclipse.ui.IViewReference; |
| import org.eclipse.ui.IWorkbenchPage; |
| import org.eclipse.ui.IWorkbenchWindow; |
| import org.eclipse.ui.IWorkingSet; |
| import org.eclipse.ui.IWorkingSetManager; |
| import org.eclipse.ui.PartInitException; |
| import org.eclipse.ui.PlatformUI; |
| import org.eclipse.ui.WorkbenchException; |
| import org.eclipse.ui.XMLMemento; |
| import org.eclipse.ui.ide.IDE; |
| import org.eclipse.ui.internal.ClosePerspectiveAction; |
| import org.eclipse.ui.internal.SaveableHelper; |
| import org.eclipse.ui.internal.WorkbenchPage; |
| import org.eclipse.ui.internal.WorkbenchPlugin; |
| import org.eclipse.ui.internal.registry.IActionSetDescriptor; |
| import org.eclipse.ui.part.FileEditorInput; |
| import org.eclipse.ui.tests.PerspectiveState; |
| import org.eclipse.ui.tests.harness.util.CallHistory; |
| import org.eclipse.ui.tests.harness.util.EmptyPerspective; |
| import org.eclipse.ui.tests.harness.util.FileUtil; |
| import org.eclipse.ui.tests.harness.util.UITestCase; |
| |
| public class IWorkbenchPageTest extends UITestCase { |
| |
| private IWorkbenchPage fActivePage; |
| |
| private IWorkbenchWindow fWin; |
| |
| private IProject proj; |
| |
| public IWorkbenchPageTest(String testName) { |
| super(testName); |
| } |
| |
| protected void doSetUp() throws Exception { |
| super.doSetUp(); |
| fWin = openTestWindow(); |
| fActivePage = fWin.getActivePage(); |
| } |
| |
| protected void doTearDown() throws Exception { |
| super.doTearDown(); |
| if (proj != null) { |
| FileUtil.deleteProject(proj); |
| proj = null; |
| } |
| } |
| |
| /** |
| * Tests the new working set API. |
| * |
| * @since 3.2 |
| */ |
| public void testWorkingSets1() { |
| IWorkbenchPage page = fActivePage; |
| IWorkingSet[] sets = page.getWorkingSets(); |
| assertNotNull(sets); |
| assertEquals(0, sets.length); |
| |
| IWorkingSetManager manager = page.getWorkbenchWindow().getWorkbench() |
| .getWorkingSetManager(); |
| |
| IWorkingSet set1 = null, set2 = null; |
| try { |
| set1 = manager.createWorkingSet("w1", new IAdaptable[0]); |
| manager.addWorkingSet(set1); |
| set2 = manager.createWorkingSet("w2", new IAdaptable[0]); |
| manager.addWorkingSet(set2); |
| |
| page.setWorkingSets(new IWorkingSet[] {set1}); |
| sets = page.getWorkingSets(); |
| |
| assertNotNull(sets); |
| assertEquals(1, sets.length); |
| assertEquals(set1, sets[0]); |
| |
| page.setWorkingSets(new IWorkingSet[0]); |
| sets = page.getWorkingSets(); |
| assertNotNull(sets); |
| assertEquals(0, sets.length); |
| |
| page.setWorkingSets(new IWorkingSet[] {set1, set2}); |
| sets = page.getWorkingSets(); |
| |
| assertNotNull(sets); |
| assertEquals(2, sets.length); |
| Set realSet = new HashSet(Arrays.asList(sets)); |
| assertTrue(realSet.contains(set1)); |
| assertTrue(realSet.contains(set2)); |
| |
| page.setWorkingSets(new IWorkingSet[0]); |
| sets = page.getWorkingSets(); |
| assertNotNull(sets); |
| assertEquals(0, sets.length); |
| } |
| finally { |
| if (set1 != null) |
| manager.removeWorkingSet(set1); |
| if (set2 != null) |
| manager.removeWorkingSet(set2); |
| } |
| } |
| |
| /** |
| * Tests the new working set API. |
| * |
| * @since 3.2 |
| */ |
| public void testWorkingSets2() { |
| fActivePage.setWorkingSets(null); |
| IWorkingSet [] sets = fActivePage.getWorkingSets(); |
| assertNotNull(sets); |
| assertEquals(0, sets.length); |
| } |
| |
| /** |
| * Tests the working set listeners. |
| * |
| * @since 3.2 |
| */ |
| public void testWorkingSets3() { |
| IWorkingSetManager manager = fActivePage.getWorkbenchWindow().getWorkbench() |
| .getWorkingSetManager(); |
| |
| IWorkingSet set1 = null; |
| final IWorkingSet [][] sets = new IWorkingSet[1][]; |
| sets[0] = new IWorkingSet[0]; |
| IPropertyChangeListener listener = new IPropertyChangeListener() { |
| |
| public void propertyChange(PropertyChangeEvent event) { |
| IWorkingSet [] oldSets = (IWorkingSet[]) event.getOldValue(); |
| assertTrue(Arrays.equals(sets[0], oldSets)); |
| sets[0] = (IWorkingSet[]) event.getNewValue(); |
| }}; |
| try { |
| set1 = manager.createWorkingSet("w1", new IAdaptable[0]); |
| manager.addWorkingSet(set1); |
| |
| fActivePage.addPropertyChangeListener(listener); |
| |
| fActivePage.setWorkingSets(new IWorkingSet[] { set1 }); |
| fActivePage.setWorkingSets(new IWorkingSet[] { }); |
| fActivePage.setWorkingSets(new IWorkingSet[] { set1 }); |
| |
| sets[0] = fActivePage.getWorkingSets(); |
| |
| assertNotNull(sets[0]); |
| assertEquals(1, sets[0].length); |
| assertEquals(set1, sets[0][0]); |
| |
| } finally { |
| fActivePage.removePropertyChangeListener(listener); |
| if (set1 != null) |
| manager.removeWorkingSet(set1); |
| } |
| } |
| |
| /** |
| * Test the VIEW_VISIBLE parameter for showView, opening the view in the |
| * stack that does not contain the active view. Ensures that the created |
| * view is not the active part but is the top part in its stack. |
| */ |
| public void testView_VISIBLE2() { |
| WorkbenchPage page = (WorkbenchPage) fActivePage; |
| try { |
| page.setPerspective(WorkbenchPlugin.getDefault() |
| .getPerspectiveRegistry().findPerspectiveWithId( |
| "org.eclipse.ui.tests.api.ViewPerspective")); |
| |
| //create a part to be active |
| IViewPart activePart = page.showView(MockViewPart.ID3); |
| |
| IViewPart createdPart = page.showView(MockViewPart.ID2, null, |
| IWorkbenchPage.VIEW_VISIBLE); |
| |
| IViewPart[] stack = page.getViewStack(createdPart); |
| assertEquals(2, stack.length); |
| |
| assertEquals(createdPart, stack[0]); |
| assertEquals(page.findView(MockViewPart.ID), stack[1]); |
| |
| assertTrue(page.isPartVisible(createdPart)); |
| |
| assertEquals(activePart, page.getActivePart()); |
| } catch (PartInitException e) { |
| fail(e.getMessage()); |
| } |
| } |
| |
| /** |
| * openEditor(IEditorInput input, String editorId, boolean activate) |
| */ |
| public void testOpenEditor4() throws Throwable { |
| proj = FileUtil.createProject("testOpenEditor"); |
| final String id = MockEditorPart.ID1; |
| IEditorInput input = new FileEditorInput(FileUtil.createFile( |
| "test.mock1", proj)); |
| MockPartListener listener = new MockPartListener(); |
| fActivePage.addPartListener(listener); |
| CallHistory callTrace = listener.getCallHistory(); |
| |
| /* |
| javadoc: The editor type is determined by mapping editorId to an editor extension |
| registered with the workbench. |
| javadoc: If activate == true the editor will be activated |
| */ |
| //open an editor with activation |
| |
| // Start with a view active in order to verify that the editor gets activated |
| fActivePage.showView(IPageLayout.ID_PROBLEM_VIEW, null, IWorkbenchPage.VIEW_ACTIVATE); |
| callTrace.clear(); |
| IEditorPart editor = IDE.openEditor(fActivePage, input, id, true); |
| assertEquals(editor.getEditorInput(), input); |
| assertEquals(editor.getSite().getId(), id); |
| assertEquals(hasEditor(editor), true); |
| assertEquals(fActivePage.getActiveEditor(), editor); |
| assertEquals(callTrace.contains("partActivated"), true); |
| |
| //we need another editor so that the editor under test can receive events. |
| //otherwise, events will be ignored. |
| IEditorPart extra = IDE.openEditor(fActivePage, FileUtil.createFile( |
| "aaaaa", proj)); |
| |
| //close the first editor after the second has opened; necessary for |
| //test to work with fix to PR 7743 |
| fActivePage.closeEditor(editor, false); |
| |
| // Start with a view active in order to verify that the editor does not get activated |
| // (note: regardless of the activate=false flag, the editor would always be activated |
| // if it is being opened in the same stack as the active editor. Making a view active |
| // initially tests the function of the activate flag) |
| fActivePage.showView(IPageLayout.ID_PROBLEM_VIEW, null, IWorkbenchPage.VIEW_ACTIVATE); |
| callTrace.clear(); |
| //open an editor without activation |
| editor = IDE.openEditor(fActivePage, input, id, false); |
| |
| assertEquals(editor.getEditorInput(), input); |
| assertEquals(editor.getSite().getId(), id); |
| assertEquals(hasEditor(editor), true); |
| assertEquals(callTrace.contains("partActivated"), false); |
| assertEquals(callTrace.contains("partBroughtToTop"), true); |
| |
| fActivePage.activate(extra); |
| |
| /* |
| javadoc: If this page already has an editor open on the target object that editor is brought to the front |
| */ |
| //open the editor under test second time without activation |
| fActivePage.showView(IPageLayout.ID_PROBLEM_VIEW, null, IWorkbenchPage.VIEW_ACTIVATE); |
| callTrace.clear(); |
| assertEquals(IDE.openEditor(fActivePage, input, id, false), editor); |
| assertEquals(callTrace.contains("partBroughtToTop"), true); |
| assertEquals(callTrace.contains("partActivated"), false); |
| |
| //activate the other editor |
| fActivePage.activate(extra); |
| |
| /* |
| javadoc: If activate == true the editor will be activated |
| */ |
| //open the editor under test second time with activation |
| fActivePage.showView(IPageLayout.ID_PROBLEM_VIEW, null, IWorkbenchPage.VIEW_ACTIVATE); |
| callTrace.clear(); |
| assertEquals(IDE.openEditor(fActivePage, input, id, true), editor); |
| assertEquals(callTrace.contains("partBroughtToTop"), true); |
| assertEquals(callTrace.contains("partActivated"), true); |
| |
| /* |
| javadoc: If activate == false but another editor in the same stack was active, the |
| new editor will be activated regardless. |
| */ |
| // Close the old editor |
| fActivePage.closeEditor(editor, false); |
| // Ensure another editor in the stack is active |
| fActivePage.activate(extra); |
| callTrace.clear(); |
| // Verify that the editor is still activated |
| IDE.openEditor(fActivePage, input, id, false); |
| assertEquals(callTrace.contains("partBroughtToTop"), true); |
| assertEquals(callTrace.contains("partActivated"), true); |
| } |
| |
| /** |
| * tests both of the following: |
| * setEditorAreaVisible() |
| * isEditorAreaVisible() |
| */ |
| public void testGet_SetEditorAreaVisible() throws Throwable { |
| fActivePage.setEditorAreaVisible(true); |
| assertTrue(fActivePage.isEditorAreaVisible() == true); |
| |
| fActivePage.setEditorAreaVisible(false); |
| assertTrue(fActivePage.isEditorAreaVisible() == false); |
| } |
| |
| |
| |
| /** |
| * openEditor(IWorkbenchPage page, IFile input) |
| */ |
| public void testOpenEditor() throws Throwable { |
| proj = FileUtil.createProject("testOpenEditor"); |
| |
| /* |
| javadoc: 1. The workbench editor registry is consulted to determine if an editor extension has been |
| registered for the file type. If so, an instance of the editor extension is opened on the file |
| */ |
| IFile file = FileUtil.createFile("test.mock1", proj); |
| IEditorPart editor = IDE.openEditor(fActivePage, file); |
| |
| boolean foundEditor = hasEditor(editor); |
| assertEquals(foundEditor, true); |
| assertEquals(fActivePage.getActiveEditor(), editor); |
| assertEquals(editor.getSite().getId(), fWorkbench.getEditorRegistry() |
| .getDefaultEditor(file.getName()).getId()); |
| |
| /* |
| javadoc: 2. Next, the native operating system will be consulted to determine if a native editor exists for |
| the file type. If so, a new process is started and the native editor is opened on the file. |
| */ |
| //can not be tested |
| /* |
| * javadoc: 3. If all else fails the file will be opened in a default |
| * text editor. |
| */ |
| |
| file = FileUtil.createFile("a.null and void", proj); |
| editor = IDE.openEditor(fActivePage, file); |
| assertEquals(hasEditor(editor), true); |
| assertEquals(fActivePage.getActiveEditor(), editor); |
| assertEquals(editor.getSite().getId(), |
| "org.eclipse.ui.DefaultTextEditor"); |
| |
| // open another editor to take the focus away from the first editor |
| IDE.openEditor(fActivePage, FileUtil.createFile("test.mock2", proj)); |
| |
| /* |
| javadoc: If this page already has an editor open on the target object that editor is activated |
| */ |
| //open the editor second time. |
| assertEquals(editor, IDE.openEditor(fActivePage, file)); |
| assertEquals(editor, fActivePage.getActiveEditor()); |
| } |
| |
| /** |
| * openEditor(IWorkbenchPage page, IFile input, String editorID) |
| */ |
| public void testOpenEditor2() throws Throwable { |
| proj = FileUtil.createProject("testOpenEditor"); |
| final IFile file = FileUtil.createFile("asfasdasdf", proj); |
| final String id = MockEditorPart.ID1; |
| |
| /* |
| javadoc: The editor type is determined by mapping editorId to an editor extension registered with the workbench. |
| */ |
| IEditorPart editor = IDE.openEditor(fActivePage, file, id); |
| assertEquals(editor.getSite().getId(), id); |
| assertEquals(hasEditor(editor), true); |
| assertEquals(fActivePage.getActiveEditor(), editor); |
| |
| //open another editor to take the focus away from the first editor |
| IDE.openEditor(fActivePage, FileUtil.createFile("test.mock2", proj)); |
| |
| /* |
| javadoc: If this page already has an editor open on the target object that editor is activated |
| */ |
| //open the first editor second time. |
| assertEquals(IDE.openEditor(fActivePage, file, id), editor); |
| assertEquals(fActivePage.getActiveEditor(), editor); |
| } |
| |
| /** |
| * openEditor(IEditorInput input,String editorId) |
| */ |
| public void testOpenEditor3() throws Throwable { |
| proj = FileUtil.createProject("testOpenEditor"); |
| final String id = MockEditorPart.ID1; |
| IEditorInput input = new FileEditorInput(FileUtil.createFile( |
| "test.mock1", proj)); |
| |
| /* |
| javadoc: The editor type is determined by mapping editorId to an editor extension registered with the workbench |
| */ |
| IEditorPart editor = IDE.openEditor(fActivePage, input, id); |
| assertEquals(editor.getEditorInput(), input); |
| assertEquals(editor.getSite().getId(), id); |
| assertEquals(hasEditor(editor), true); |
| assertEquals(fActivePage.getActiveEditor(), editor); |
| |
| //open another editor to take the focus away from the first editor |
| IDE.openEditor(fActivePage, FileUtil.createFile("test.mock2", proj)); |
| |
| /* |
| javadoc: If this page already has an editor open on the target object that editor is activated |
| */ |
| //open the first editor second time. |
| assertEquals(IDE.openEditor(fActivePage, input, id), editor); |
| assertEquals(fActivePage.getActiveEditor(), editor); |
| } |
| |
| /** |
| * openEditor(IMarker marker) |
| */ |
| public void testOpenEditor5() throws Throwable { |
| proj = FileUtil.createProject("testOpenEditor"); |
| IMarker marker = FileUtil.createFile("aa.mock2", proj).createMarker( |
| IMarker.TASK); |
| CallHistory callTrace; |
| |
| /* |
| javadoc: the cursor and selection state of the editor is then updated from information |
| recorded in the marker. |
| */ |
| //open the registered editor for the marker resource |
| IEditorPart editor = IDE.openEditor(fActivePage, marker); |
| callTrace = ((MockEditorPart) editor).getCallHistory(); |
| assertEquals(editor.getSite().getId(), MockEditorPart.ID2); |
| assertEquals(hasEditor(editor), true); |
| assertEquals(fActivePage.getActiveEditor(), editor); |
| assertEquals(callTrace.contains("gotoMarker"), true); |
| fActivePage.closeEditor(editor, false); |
| |
| /* |
| javadoc: If the marker contains an EDITOR_ID_ATTR attribute the attribute value will be used to |
| determine the editor type to be opened |
| */ |
| marker.setAttribute(IDE.EDITOR_ID_ATTR, MockEditorPart.ID1); |
| editor = IDE.openEditor(fActivePage, marker); |
| callTrace = ((MockEditorPart) editor).getCallHistory(); |
| assertEquals(editor.getSite().getId(), MockEditorPart.ID1); |
| assertEquals(hasEditor(editor), true); |
| assertEquals(fActivePage.getActiveEditor(), editor); |
| assertEquals(callTrace.contains("gotoMarker"), true); |
| //do not close the editor this time |
| |
| /* |
| javdoc: If this page already has an editor open on the target object that editor is activated |
| */ |
| callTrace.clear(); |
| assertEquals(IDE.openEditor(fActivePage, marker), editor); |
| assertEquals(fActivePage.getActiveEditor(), editor); |
| assertEquals(callTrace.contains("gotoMarker"), true); |
| fActivePage.closeEditor(editor, false); |
| } |
| |
| /** |
| * openEditor(IMarker marker, boolean activate) |
| */ |
| public void testOpenEditor6() throws Throwable { |
| proj = FileUtil.createProject("testOpenEditor"); |
| IMarker marker = FileUtil.createFile("aa.mock2", proj).createMarker( |
| IMarker.TASK); |
| MockPartListener listener = new MockPartListener(); |
| fActivePage.addPartListener(listener); |
| CallHistory listenerCall = listener.getCallHistory(); |
| CallHistory editorCall; |
| |
| //we need another editor so that the editor under test can receive events. |
| //otherwise, events will be ignored. |
| IEditorPart extra = IDE.openEditor(fActivePage, FileUtil.createFile( |
| "aaaaa", proj)); |
| |
| /* |
| javadoc: If activate == true the editor will be activated |
| */ |
| //open the registered editor for the marker resource with activation |
| IEditorPart editor = IDE.openEditor(fActivePage, marker, true); |
| editorCall = ((MockEditorPart) editor).getCallHistory(); |
| assertEquals(editor.getSite().getId(), MockEditorPart.ID2); |
| assertEquals(hasEditor(editor), true); |
| assertEquals(fActivePage.getActiveEditor(), editor); |
| |
| /* |
| javadoc: the cursor and selection state of the editor is then updated from information |
| recorded in the marker. |
| */ |
| assertEquals(editorCall.contains("gotoMarker"), true); |
| fActivePage.closeEditor(editor, false); |
| |
| fActivePage.activate(extra); |
| |
| //open the registered editor for the marker resource without activation |
| fActivePage.showView(IPageLayout.ID_PROBLEM_VIEW, null, IWorkbenchPage.VIEW_ACTIVATE); |
| listenerCall.clear(); |
| editor = IDE.openEditor(fActivePage, marker, false); |
| editorCall = ((MockEditorPart) editor).getCallHistory(); |
| assertEquals(editor.getSite().getId(), MockEditorPart.ID2); |
| assertEquals(hasEditor(editor), true); |
| assertEquals(listenerCall.contains("partBroughtToTop"), true); |
| assertEquals(listenerCall.contains("partActivated"), false); |
| assertEquals(editorCall.contains("gotoMarker"), true); |
| fActivePage.closeEditor(editor, false); |
| |
| /* |
| javadoc: If the marker contains an EDITOR_ID_ATTR attribute the attribute value will be used to |
| determine the editor type to be opened |
| */ |
| String id = MockEditorPart.ID1; |
| marker.setAttribute(IDE.EDITOR_ID_ATTR, id); |
| |
| //open an editor with activation |
| listenerCall.clear(); |
| |
| editor = IDE.openEditor(fActivePage, marker, true); |
| editorCall = ((MockEditorPart) editor).getCallHistory(); |
| assertEquals(editor.getSite().getId(), id); |
| assertEquals(hasEditor(editor), true); |
| assertEquals(fActivePage.getActiveEditor(), editor); |
| assertEquals(editorCall.contains("gotoMarker"), true); |
| fActivePage.closeEditor(editor, false); |
| |
| fActivePage.activate(extra); |
| |
| //open an editor without activation |
| fActivePage.showView(IPageLayout.ID_PROBLEM_VIEW, null, IWorkbenchPage.VIEW_ACTIVATE); |
| listenerCall.clear(); |
| editor = IDE.openEditor(fActivePage, marker, false); |
| editorCall = ((MockEditorPart) editor).getCallHistory(); |
| assertEquals(editor.getSite().getId(), id); |
| assertEquals(hasEditor(editor), true); |
| assertEquals(editorCall.contains("gotoMarker"), true); |
| assertEquals(listenerCall.contains("partActivated"), false); |
| assertEquals(listenerCall.contains("partBroughtToTop"), true); |
| //do not close the editor this time |
| |
| fActivePage.activate(extra); |
| /* |
| javadoc: If this page already has an editor open on the target object that editor is brought to front |
| Note: we need to make a non-editor active first or bringing the editor to front would activate it |
| */ |
| //open the editor second time without activation |
| fActivePage.showView(IPageLayout.ID_PROBLEM_VIEW, null, IWorkbenchPage.VIEW_ACTIVATE); |
| listenerCall.clear(); |
| assertEquals(IDE.openEditor(fActivePage, marker, false), editor); |
| assertEquals(listenerCall.contains("partBroughtToTop"), true); |
| assertEquals(listenerCall.contains("partActivated"), false); |
| |
| fActivePage.activate(extra); |
| |
| /* |
| javdoc: If activate == true the editor will be activated |
| */ |
| //open the editor second time with activation |
| listenerCall.clear(); |
| assertEquals(IDE.openEditor(fActivePage, marker, true), editor); |
| assertEquals(editorCall.contains("gotoMarker"), true); |
| assertEquals(listenerCall.contains("partBroughtToTop"), true); |
| assertEquals(listenerCall.contains("partActivated"), true); |
| |
| /* |
| javadoc: If activate == false but another editor in the same stack was active, the |
| new editor will be activated regardless. |
| */ |
| // Close the old editor |
| fActivePage.closeEditor(editor, false); |
| // Ensure another editor in the stack is active |
| fActivePage.activate(extra); |
| listenerCall.clear(); |
| // Verify that the editor is still activated |
| IDE.openEditor(fActivePage, marker, false); |
| assertEquals(listenerCall.contains("partBroughtToTop"), true); |
| assertEquals(listenerCall.contains("partActivated"), true); |
| } |
| |
| |
| public void testGetPerspective() throws Throwable { |
| assertNotNull(fActivePage.getPerspective()); |
| |
| IWorkbenchPage page = fWin.openPage(EmptyPerspective.PERSP_ID, getPageInput()); |
| assertEquals(EmptyPerspective.PERSP_ID, page.getPerspective().getId()); |
| } |
| |
| public void testSetPerspective() throws Throwable { |
| IPerspectiveDescriptor per = PlatformUI.getWorkbench() |
| .getPerspectiveRegistry().findPerspectiveWithId( |
| EmptyPerspective.PERSP_ID); |
| fActivePage.setPerspective(per); |
| assertEquals(per, fActivePage.getPerspective()); |
| } |
| |
| public void testGetLabel() { |
| assertNotNull(fActivePage.getLabel()); |
| } |
| |
| public void testGetInput() throws Throwable { |
| IAdaptable input = getPageInput(); |
| IWorkbenchPage page = fWin.openPage(input); |
| assertEquals(input, page.getInput()); |
| } |
| |
| public void testActivate() throws Throwable { |
| MockViewPart part = (MockViewPart) fActivePage |
| .showView(MockViewPart.ID); |
| MockViewPart part2 = (MockViewPart) fActivePage |
| .showView(MockViewPart.ID2); |
| |
| MockPartListener listener = new MockPartListener(); |
| fActivePage.addPartListener(listener); |
| fActivePage.activate(part); |
| |
| CallHistory callTrace; |
| |
| callTrace = part2.getCallHistory(); |
| callTrace.clear(); |
| fActivePage.activate(part2); |
| assertTrue(callTrace.contains("setFocus")); |
| assertTrue(listener.getCallHistory().contains("partActivated")); |
| |
| callTrace = part.getCallHistory(); |
| callTrace.clear(); |
| fActivePage.activate(part); |
| assertTrue(callTrace.contains("setFocus")); |
| assertTrue(listener.getCallHistory().contains("partActivated")); |
| } |
| |
| public void testBringToTop() throws Throwable { |
| proj = FileUtil.createProject("testOpenEditor"); |
| IEditorPart part = IDE.openEditor(fActivePage, FileUtil.createFile( |
| "a.mock1", proj)); |
| IEditorPart part2 = IDE.openEditor(fActivePage, FileUtil.createFile( |
| "b.mock1", proj)); |
| |
| MockPartListener listener = new MockPartListener(); |
| fActivePage.addPartListener(listener); |
| CallHistory callTrace = listener.getCallHistory(); |
| |
| //at this point, part2 is active |
| fActivePage.bringToTop(part); |
| assertEquals(callTrace.contains("partBroughtToTop"), true); |
| |
| callTrace.clear(); |
| fActivePage.bringToTop(part2); |
| assertEquals(callTrace.contains("partBroughtToTop"), true); |
| } |
| |
| public void testGetWorkbenchWindow() { |
| /* |
| * Commented out because until test case can be updated to work |
| * with new window/page/perspective implementation |
| * |
| assertEquals(fActivePage.getWorkbenchWindow(), fWin); |
| IWorkbenchPage page = openTestPage(fWin); |
| assertEquals(page.getWorkbenchWindow(), fWin); |
| */ |
| } |
| |
| public void testShowView() throws Throwable { |
| /* |
| javadoc: Shows a view in this page and give it focus |
| */ |
| MockViewPart view = (MockViewPart) fActivePage |
| .showView(MockViewPart.ID); |
| assertNotNull(view); |
| assertTrue(view.getCallHistory().verifyOrder( |
| new String[] { "init", "createPartControl", "setFocus" })); |
| |
| fActivePage.showView(MockViewPart.ID2); |
| |
| /* |
| javadoc: If the view is already visible, it is given focus |
| */ |
| CallHistory callTrace = view.getCallHistory(); |
| callTrace.clear(); |
| assertEquals(fActivePage.showView(MockViewPart.ID), view); |
| assertEquals(callTrace.contains("setFocus"), true); |
| } |
| |
| /** |
| * Tests showing multi-instance views (docked normally). |
| */ |
| public void testShowViewMult() throws Throwable { |
| /* |
| javadoc: Shows the view identified by the given view id and secondary id |
| in this page and gives it focus. |
| This allows multiple instances of a particular view to be created. |
| They are disambiguated using the secondary id. |
| */ |
| MockViewPart view = (MockViewPart) fActivePage |
| .showView(MockViewPart.IDMULT); |
| assertNotNull(view); |
| assertTrue(view.getCallHistory().verifyOrder( |
| new String[] { "init", "createPartControl", "setFocus" })); |
| MockViewPart view2 = (MockViewPart) fActivePage.showView( |
| MockViewPart.IDMULT, "2", IWorkbenchPage.VIEW_ACTIVATE); |
| assertNotNull(view2); |
| assertTrue(view2.getCallHistory().verifyOrder( |
| new String[] { "init", "createPartControl", "setFocus" })); |
| assertTrue(!view.equals(view2)); |
| MockViewPart view3 = (MockViewPart) fActivePage.showView( |
| MockViewPart.IDMULT, "3", IWorkbenchPage.VIEW_ACTIVATE); |
| assertNotNull(view3); |
| assertTrue(view3.getCallHistory().verifyOrder( |
| new String[] { "init", "createPartControl", "setFocus" })); |
| assertTrue(!view.equals(view3)); |
| assertTrue(!view2.equals(view3)); |
| |
| /* |
| javadoc: If there is a view identified by the given view id and |
| secondary id already open in this page, it is given focus. |
| */ |
| CallHistory callTrace = view.getCallHistory(); |
| callTrace.clear(); |
| assertEquals(fActivePage.showView(MockViewPart.IDMULT), view); |
| assertEquals(callTrace.contains("setFocus"), true); |
| CallHistory callTrace2 = view2.getCallHistory(); |
| callTrace.clear(); |
| callTrace2.clear(); |
| assertEquals(fActivePage.showView(MockViewPart.IDMULT, "2", |
| IWorkbenchPage.VIEW_ACTIVATE), view2); |
| assertEquals(callTrace2.contains("setFocus"), true); |
| assertEquals(callTrace.contains("setFocus"), false); |
| CallHistory callTrace3 = view3.getCallHistory(); |
| callTrace.clear(); |
| callTrace2.clear(); |
| callTrace3.clear(); |
| assertEquals(fActivePage.showView(MockViewPart.IDMULT, "3", |
| IWorkbenchPage.VIEW_ACTIVATE), view3); |
| assertEquals(callTrace3.contains("setFocus"), true); |
| assertEquals(callTrace.contains("setFocus"), false); |
| assertEquals(callTrace2.contains("setFocus"), false); |
| |
| /* |
| javadoc: If a secondary id is given, the view must allow multiple instances by |
| having specified allowMultiple="true" in its extension. |
| */ |
| boolean exceptionThrown = false; |
| try { |
| fActivePage.showView(MockViewPart.ID, "2", |
| IWorkbenchPage.VIEW_ACTIVATE); |
| } catch (PartInitException e) { |
| assertEquals(e.getMessage().indexOf("mult") != -1, true); |
| exceptionThrown = true; |
| } |
| assertEquals(exceptionThrown, true); |
| } |
| |
| /** |
| * Tests showing multi-instance views (as fast views). |
| * This is a regression test for bug 76669 - [Perspectives] NullPointerException in Perspective.getFastViewWidthRatio() |
| */ |
| public void testShowViewMultFast() throws Throwable { |
| /* |
| javadoc: Shows the view identified by the given view id and secondary id |
| in this page and gives it focus. |
| This allows multiple instances of a particular view to be created. |
| They are disambiguated using the secondary id. |
| */ |
| MockViewPart view = (MockViewPart) fActivePage |
| .showView(MockViewPart.IDMULT); |
| assertNotNull(view); |
| assertTrue(view.getCallHistory().verifyOrder( |
| new String[] { "init", "createPartControl", "setFocus" })); |
| MockViewPart view2 = (MockViewPart) fActivePage.showView( |
| MockViewPart.IDMULT, "2", IWorkbenchPage.VIEW_ACTIVATE); |
| assertNotNull(view2); |
| assertTrue(view2.getCallHistory().verifyOrder( |
| new String[] { "init", "createPartControl", "setFocus" })); |
| assertTrue(!view.equals(view2)); |
| |
| WorkbenchPage page = (WorkbenchPage) fActivePage; |
| IViewReference ref = (IViewReference) page.getReference(view); |
| IViewReference ref2 = (IViewReference) page.getReference(view2); |
| page.addFastView(ref); |
| page.addFastView(ref2); |
| |
| page.activate(view); |
| assertEquals(view, page.getActivePart()); |
| |
| page.activate(view2); |
| assertEquals(view2, page.getActivePart()); |
| } |
| |
| /** |
| * Tests saving the page state when there is a fast view that is also a multi-instance view. |
| * This is a regression test for bug 76669 - [Perspectives] NullPointerException in Perspective.getFastViewWidthRatio() |
| */ |
| public void testBug76669() throws Throwable { |
| MockViewPart view = (MockViewPart) fActivePage |
| .showView(MockViewPart.IDMULT); |
| MockViewPart view2 = (MockViewPart) fActivePage.showView( |
| MockViewPart.IDMULT, "2", IWorkbenchPage.VIEW_ACTIVATE); |
| |
| WorkbenchPage page = (WorkbenchPage) fActivePage; |
| IViewReference ref = (IViewReference) page.getReference(view); |
| IViewReference ref2 = (IViewReference) page.getReference(view2); |
| page.addFastView(ref); |
| page.addFastView(ref2); |
| |
| IMemento memento = XMLMemento.createWriteRoot("page"); |
| page.saveState(memento); |
| IMemento persps = memento.getChild("perspectives"); |
| IMemento persp = persps.getChildren("perspective")[0]; |
| IMemento[] fastViews = persp.getChild("fastViews").getChildren("view"); |
| assertEquals(2, fastViews.length); |
| } |
| |
| public void testFindView() throws Throwable { |
| String id = MockViewPart.ID3; |
| //id of valid, but not open view |
| assertNull(fActivePage.findView(id)); |
| |
| IViewPart view = fActivePage.showView(id); |
| assertEquals(fActivePage.findView(id), view); |
| |
| //close view |
| fActivePage.hideView(view); |
| assertNull(fActivePage.findView(id)); |
| } |
| |
| public void testFindViewReference() throws Throwable { |
| fActivePage.getWorkbenchWindow().getWorkbench().showPerspective( |
| SessionPerspective.ID, fActivePage.getWorkbenchWindow()); |
| assertNull(fActivePage.findViewReference(MockViewPart.ID4)); |
| |
| fActivePage.showView(MockViewPart.ID4); |
| assertNotNull(fActivePage.findViewReference(MockViewPart.ID4)); |
| } |
| |
| public void testGetViews() throws Throwable { |
| int totalBefore = fActivePage.getViewReferences().length; |
| |
| IViewPart view = fActivePage.showView(MockViewPart.ID2); |
| assertEquals(hasView(view), true); |
| assertEquals(fActivePage.getViewReferences().length, totalBefore + 1); |
| |
| fActivePage.hideView(view); |
| assertEquals(hasView(view), false); |
| assertEquals(fActivePage.getViewReferences().length, totalBefore); |
| } |
| |
| public void testHideViewWithPart() throws Throwable { |
| // test that nothing bad happens with a null parameter |
| try { |
| fActivePage.hideView((IViewPart) null); |
| } catch (RuntimeException e) { |
| fail(e.getMessage()); |
| } |
| |
| IViewPart view = fActivePage.showView(MockViewPart.ID3); |
| |
| fActivePage.hideView(view); |
| CallHistory callTrace = ((MockViewPart) view).getCallHistory(); |
| assertTrue(callTrace.contains("dispose")); |
| } |
| |
| public void testHideViewWithReference() throws Throwable { |
| // test that nothing bad happens with a null parameter |
| try { |
| fActivePage.hideView((IViewReference) null); |
| } catch (RuntimeException e) { |
| fail(e.getMessage()); |
| } |
| |
| IViewPart view = fActivePage.showView(MockViewPart.ID4); |
| IViewReference ref = fActivePage.findViewReference(MockViewPart.ID4); |
| fActivePage.hideView(ref); |
| CallHistory callTrace = ((MockViewPart) view).getCallHistory(); |
| assertTrue(callTrace.contains("dispose")); |
| |
| } |
| |
| public void testHideSaveableView() throws Throwable { |
| String viewId = SaveableMockViewPart.ID; |
| SaveableMockViewPart view = (SaveableMockViewPart) fActivePage.showView(viewId); |
| fActivePage.hideView(view); |
| CallHistory callTrace = view.getCallHistory(); |
| assertTrue(callTrace.contains("isDirty")); |
| assertTrue(callTrace.contains("dispose")); |
| assertEquals(fActivePage.findView(viewId), null); |
| |
| try { |
| SaveableHelper.testSetAutomatedResponse(1); // No |
| view = (SaveableMockViewPart) fActivePage.showView(viewId); |
| view.setDirty(true); |
| fActivePage.hideView(view); |
| callTrace = view.getCallHistory(); |
| assertTrue(callTrace.contains("isDirty")); |
| assertFalse(callTrace.contains("doSave")); |
| assertTrue(callTrace.contains("dispose")); |
| assertEquals(fActivePage.findView(viewId), null); |
| |
| SaveableHelper.testSetAutomatedResponse(2); // Cancel |
| view = (SaveableMockViewPart) fActivePage.showView(viewId); |
| view.setDirty(true); |
| fActivePage.hideView(view); |
| callTrace = view.getCallHistory(); |
| assertTrue(callTrace.contains("isDirty")); |
| assertFalse(callTrace.contains("doSave")); |
| assertFalse(callTrace.contains("dispose")); |
| assertEquals(fActivePage.findView(viewId), view); |
| |
| SaveableHelper.testSetAutomatedResponse(0); // Yes |
| view = (SaveableMockViewPart) fActivePage.showView(viewId); |
| view.setDirty(true); |
| fActivePage.hideView(view); |
| callTrace = view.getCallHistory(); |
| assertTrue(callTrace.contains("isDirty")); |
| assertTrue(callTrace.contains("doSave")); |
| assertTrue(callTrace.contains("dispose")); |
| assertEquals(fActivePage.findView(viewId), null); |
| |
| // don't leave the view showing, or the UI will block on window close |
| } |
| finally { |
| SaveableHelper.testSetAutomatedResponse(-1); // restore default (prompt) |
| } |
| } |
| |
| /** |
| * Tests that a close will fall back to the default if the view returns |
| * ISaveable2.DEFAULT. |
| * |
| * @throws Throwable |
| */ |
| public void testCloseWithSaveNeeded() throws Throwable { |
| String viewId = UserSaveableMockViewPart.ID; |
| UserSaveableMockViewPart view = (UserSaveableMockViewPart) fActivePage |
| .showView(viewId); |
| fActivePage.hideView(view); |
| |
| UserSaveableMockViewPart view2 = null; |
| |
| CallHistory callTrace = view.getCallHistory(); |
| assertTrue(callTrace.contains("isDirty")); |
| assertTrue(callTrace.contains("dispose")); |
| assertEquals(fActivePage.findView(UserSaveableMockViewPart.ID), null); |
| |
| try { |
| SaveableHelper.testSetAutomatedResponse(3); // DEFAULT |
| view = (UserSaveableMockViewPart) fActivePage.showView(viewId); |
| view.setDirty(true); |
| view2 = (UserSaveableMockViewPart) fActivePage.showView(viewId, |
| "2", IWorkbenchPage.VIEW_ACTIVATE); |
| assertNotNull(view2); |
| view2.setDirty(true); |
| |
| WorkbenchPage page = (WorkbenchPage) fActivePage; |
| page.getEditorManager().saveAll(true, false); |
| |
| assertFalse(view.isDirty()); |
| assertFalse(view2.isDirty()); |
| |
| callTrace = view.getCallHistory(); |
| fActivePage.hideView(view); |
| fActivePage.hideView(view2); |
| |
| assertTrue(callTrace.contains("isDirty")); |
| assertTrue(callTrace.contains("doSave")); |
| assertEquals(fActivePage.findView(viewId), null); |
| |
| // don't leave the view showing, or the UI will block on window |
| // close |
| } finally { |
| SaveableHelper.testSetAutomatedResponse(SaveableHelper.USER_RESPONSE); // restore default |
| // (prompt) |
| } |
| } |
| |
| /** |
| * Tests that a close will fall back to the default if the view returns |
| * ISaveable2.DEFAULT. |
| * |
| * @throws Throwable |
| */ |
| public void testSaveEffectsSharedModel() throws Throwable { |
| String viewId = UserSaveableSharedViewPart.ID; |
| UserSaveableSharedViewPart view = null; |
| |
| UserSaveableSharedViewPart view2 = null; |
| |
| assertEquals(fActivePage.findView(UserSaveableSharedViewPart.ID), null); |
| |
| try { |
| SaveableHelper.testSetAutomatedResponse(3); // DEFAULT |
| UserSaveableSharedViewPart.SharedModel model = new UserSaveableSharedViewPart.SharedModel(); |
| view = (UserSaveableSharedViewPart) fActivePage.showView(viewId); |
| view.setSharedModel(model); |
| |
| view2 = (UserSaveableSharedViewPart) fActivePage.showView(viewId, |
| "2", IWorkbenchPage.VIEW_ACTIVATE); |
| assertNotNull(view2); |
| view2.setSharedModel(model); |
| |
| WorkbenchPage page = (WorkbenchPage) fActivePage; |
| page.getEditorManager().saveAll(true, false); |
| |
| assertFalse(view.isDirty()); |
| assertFalse(view2.isDirty()); |
| |
| CallHistory callTrace = view.getCallHistory(); |
| CallHistory call2 = view2.getCallHistory(); |
| |
| assertTrue(callTrace.contains("isDirty")); |
| assertTrue(call2.contains("isDirty")); |
| assertTrue("At least one should call doSave", callTrace |
| .contains("doSave") |
| || call2.contains("doSave")); |
| assertFalse("Both should not call doSave", callTrace |
| .contains("doSave") |
| && call2.contains("doSave")); |
| |
| // don't leave the view showing, or the UI will block on window |
| // close |
| } finally { |
| SaveableHelper |
| .testSetAutomatedResponse(SaveableHelper.USER_RESPONSE); // restore |
| // default |
| // (prompt) |
| fActivePage.hideView(view); |
| fActivePage.hideView(view2); |
| } |
| } |
| |
| public void testClose() throws Throwable { |
| IWorkbenchPage page = openTestPage(fWin); |
| |
| proj = FileUtil.createProject("testOpenEditor"); |
| final IFile file = FileUtil.createFile("aaa.mock1", proj); |
| IEditorPart editor = IDE.openEditor(page, file); |
| CallHistory callTrace = ((MockEditorPart) editor).getCallHistory(); |
| callTrace.clear(); |
| |
| /* |
| javadoc: If the page has open editors with unsaved content and save is true, the user will be given the opportunity to save them |
| */ |
| assertEquals(page.close(), true); |
| assertEquals(callTrace |
| .verifyOrder(new String[] { "isDirty", "dispose" }), true); |
| assertEquals(fWin.getActivePage(), fActivePage); |
| } |
| |
| public void testCloseEditor() throws Throwable { |
| proj = FileUtil.createProject("testOpenEditor"); |
| final IFile file = FileUtil.createFile("test.mock1", proj); |
| IEditorPart editor; |
| CallHistory callTrace; |
| MockEditorPart mock; |
| |
| /* |
| javadoc: Parameters: save - true to save the editor contents if required (recommended) |
| */ |
| //create a clean editor that needs to be saved on closing |
| editor = IDE.openEditor(fActivePage, file); |
| mock = (MockEditorPart) editor; |
| mock.setSaveNeeded(true); |
| callTrace = mock.getCallHistory(); |
| callTrace.clear(); |
| //close the editor with save confirmation |
| assertEquals(fActivePage.closeEditor(editor, true), true); |
| assertEquals(callTrace |
| .verifyOrder(new String[] { "isDirty", "dispose" }), true); |
| |
| /* |
| javadoc: If the editor has unsaved content and save is true, the user will be given the opportunity to save it. |
| */ |
| //can't be tested |
| /* |
| javadoc: Parameters: save - false to discard any unsaved changes |
| */ |
| //create a dirty editor |
| editor = IDE.openEditor(fActivePage, file); |
| mock = (MockEditorPart) editor; |
| mock.setDirty(true); |
| mock.setSaveNeeded(true); |
| callTrace = mock.getCallHistory(); |
| callTrace.clear(); |
| //close the editor and discard changes |
| assertEquals(fActivePage.closeEditor(editor, false), true); |
| assertEquals(callTrace.contains("isSaveOnCloseNeeded"), false); |
| /* |
| * It is possible that some action may query the isDirty value of |
| * the editor to update its enabled state. There is nothing wrong |
| * in doing that, so do not test for no isDirty call here. |
| * |
| * assertEquals(callTrace.contains( "isDirty"), false); |
| */ |
| assertEquals(callTrace.contains("doSave"), false); |
| assertEquals(callTrace.contains("dispose"), true); |
| } |
| |
| public void testCloseEditors() throws Throwable { |
| int total = 5; |
| final IFile[] files = new IFile[total]; |
| IEditorPart[] editors = new IEditorPart[total]; |
| IEditorReference[] editorRefs = new IEditorReference[total]; |
| CallHistory[] callTraces = new CallHistory[total]; |
| MockEditorPart[] mocks = new MockEditorPart[total]; |
| |
| proj = FileUtil.createProject("testCloseEditors"); |
| for (int i = 0; i < total; i++) |
| files[i] = FileUtil.createFile(i + ".mock2", proj); |
| |
| /* |
| javadoc: If the page has open editors with unsaved content and save is true, the user will be given the opportunity to save them. |
| */ |
| //close all clean editors with confirmation |
| for (int i = 0; i < total; i++) { |
| editors[i] = IDE.openEditor(fActivePage, files[i]); |
| callTraces[i] = ((MockEditorPart) editors[i]).getCallHistory(); |
| } |
| |
| editorRefs = fActivePage.getEditorReferences(); |
| assertEquals(fActivePage.closeEditors(editorRefs, true), true); |
| for (int i = 0; i < total; i++) { |
| assertEquals(callTraces[i].contains("isDirty"), true); |
| assertEquals(callTraces[i].contains("doSave"), false); |
| callTraces[i].clear(); |
| } |
| |
| //close all dirty editors with confirmation |
| //can't be tested |
| |
| //close all dirty editors discarding them |
| for (int i = 0; i < total; i++) { |
| editors[i] = IDE.openEditor(fActivePage, files[i]); |
| mocks[i] = (MockEditorPart) editors[i]; |
| mocks[i].setDirty(true); |
| callTraces[i] = mocks[i].getCallHistory(); |
| } |
| editorRefs = fActivePage.getEditorReferences(); |
| assertEquals(fActivePage.closeEditors(editorRefs, false), true); |
| for (int i = 0; i < total; i++) { |
| assertEquals(callTraces[i].contains("doSave"), false); |
| } |
| |
| //close empty array of editors |
| total = 1; |
| for (int i = 0; i < total; i++) { |
| editors[i] = IDE.openEditor(fActivePage, files[i]); |
| mocks[i] = (MockEditorPart) editors[i]; |
| mocks[i].setDirty(true); |
| callTraces[i] = mocks[i].getCallHistory(); |
| } |
| // empty array test |
| editorRefs = new IEditorReference[0]; |
| assertEquals(fActivePage.closeEditors(editorRefs, true), true); |
| for (int i = 0; i < total; i++) { |
| assertEquals(callTraces[i].contains("isDirty"), true); |
| assertEquals(callTraces[i].contains("doSave"), false); |
| callTraces[i].clear(); |
| } |
| |
| // close the last remaining editor, with save=false |
| editorRefs = fActivePage.getEditorReferences(); |
| fActivePage.closeEditors(editorRefs, false); |
| } |
| |
| public void testCloseAllEditors() throws Throwable { |
| int total = 5; |
| final IFile[] files = new IFile[total]; |
| IEditorPart[] editors = new IEditorPart[total]; |
| CallHistory[] callTraces = new CallHistory[total]; |
| MockEditorPart[] mocks = new MockEditorPart[total]; |
| |
| proj = FileUtil.createProject("testOpenEditor"); |
| for (int i = 0; i < total; i++) |
| files[i] = FileUtil.createFile(i + ".mock2", proj); |
| |
| /* |
| javadoc: If the page has open editors with unsaved content and save is true, the user will be given the opportunity to save them. |
| */ |
| //close all clean editors with confirmation |
| for (int i = 0; i < total; i++) { |
| editors[i] = IDE.openEditor(fActivePage, files[i]); |
| callTraces[i] = ((MockEditorPart) editors[i]).getCallHistory(); |
| } |
| assertEquals(fActivePage.closeAllEditors(true), true); |
| for (int i = 0; i < total; i++) { |
| assertEquals(callTraces[i].contains("isDirty"), true); |
| assertEquals(callTraces[i].contains("doSave"), false); |
| callTraces[i].clear(); |
| } |
| |
| //close all dirty editors with confirmation |
| //can't be tested |
| |
| //close all dirty editors discarding them |
| for (int i = 0; i < total; i++) { |
| editors[i] = IDE.openEditor(fActivePage, files[i]); |
| mocks[i] = (MockEditorPart) editors[i]; |
| mocks[i].setDirty(true); |
| callTraces[i] = mocks[i].getCallHistory(); |
| } |
| assertEquals(fActivePage.closeAllEditors(false), true); |
| for (int i = 0; i < total; i++) { |
| assertEquals(callTraces[i].contains("doSave"), false); |
| } |
| } |
| |
| public void testSaveEditor() throws Throwable { |
| proj = FileUtil.createProject("testOpenEditor"); |
| final IFile file = FileUtil.createFile("test.mock1", proj); |
| IEditorPart editor; |
| CallHistory callTrace; |
| MockEditorPart mock; |
| |
| //create a clean editor |
| editor = IDE.openEditor(fActivePage, file); |
| mock = (MockEditorPart) editor; |
| callTrace = mock.getCallHistory(); |
| callTrace.clear(); |
| |
| /* |
| javadoc: Saves the contents of the given editor if dirty. |
| If not, this method returns without effect |
| */ |
| //save the clean editor with confirmation |
| assertEquals(fActivePage.saveEditor(editor, true), true); |
| assertEquals(callTrace.contains("isDirty"), true); |
| assertEquals(callTrace.contains("doSave"), false); |
| |
| /* |
| javadoc: If confirm is true the user is prompted to confirm the command. |
| */ |
| //can't be tested |
| /* |
| javadoc: Otherwise, the save happens without prompt. |
| */ |
| //save the clean editor without confirmation |
| assertEquals(fActivePage.saveEditor(editor, false), true); |
| assertEquals(callTrace.contains("isDirty"), true); |
| assertEquals(callTrace.contains("doSave"), false); |
| |
| //save the dirty editor without confirmation |
| mock.setDirty(true); |
| callTrace.clear(); |
| assertEquals(fActivePage.saveEditor(editor, false), true); |
| assertEquals(callTrace |
| .verifyOrder(new String[] { "isDirty", "doSave" }), true); |
| } |
| |
| public void testIDESaveAllEditors() throws Throwable { |
| int total = 3; |
| |
| final IFile[] files = new IFile[total]; |
| IEditorPart[] editors = new IEditorPart[total]; |
| CallHistory[] callTraces = new CallHistory[total]; |
| MockEditorPart[] mocks = new MockEditorPart[total]; |
| |
| proj = FileUtil.createProject("testOpenEditor"); |
| for (int i = 0; i < total; i++) { |
| files[i] = FileUtil.createFile(i + ".mock2", proj); |
| editors[i] = IDE.openEditor(fActivePage, files[i]); |
| mocks[i] = (MockEditorPart) editors[i]; |
| callTraces[i] = mocks[i].getCallHistory(); |
| } |
| |
| /* |
| javadoc: If there are no dirty editors this method returns without effect. |
| javadoc: If confirm is true the user is prompted to confirm the command |
| */ |
| //save all clean editors with confirmation |
| assertEquals(IDE.saveAllEditors(new IResource[] { proj }, true), true); |
| for (int i = 0; i < total; i++) { |
| assertEquals(callTraces[i].contains("isDirty"), true); |
| assertEquals(callTraces[i].contains("doSave"), false); |
| callTraces[i].clear(); |
| } |
| |
| //save all dirty editors with confirmation can't be tested |
| |
| /* |
| javadoc: Parameters: confirm - false to save unsaved changes without asking |
| */ |
| //save all clean editors without confirmation |
| assertEquals(IDE.saveAllEditors(new IResource[] { proj }, false), true); |
| for (int i = 0; i < total; i++) { |
| assertEquals(callTraces[i].contains("isDirty"), true); |
| assertEquals(callTraces[i].contains("doSave"), false); |
| callTraces[i].clear(); |
| } |
| |
| //save all dirty editors with resource that IS NOT a parent |
| // of the contents of the dirty editors without confirmation, this should not |
| // save any as they are not parented by the resource provided |
| for (int i = 0; i < total; i++) |
| mocks[i].setDirty(true); |
| |
| IResource emptyProj = FileUtil |
| .createProject("testOpenEditorEmptyProject"); |
| assertEquals(IDE.saveAllEditors(new IResource[] { emptyProj }, false), |
| true); |
| for (int i = 0; i < total; i++) { |
| // the editors were not in the empty project hence still dirty |
| assertEquals(mocks[i].isDirty(), true); |
| callTraces[i].clear(); |
| } |
| |
| //save all dirty editors with resource that IS a parent |
| // of the contents of the editors without confirmation, this should |
| // save them as they are parented by the resource provided |
| assertEquals(IDE.saveAllEditors(new IResource[] { proj }, false), true); |
| for (int i = 0; i < total; i++) { |
| // the editors were not in the empty project hence still dirty |
| assertEquals(mocks[i].isDirty(), false); |
| assertEquals(callTraces[i].contains("isDirty"), true); |
| assertEquals(callTraces[i].contains("doSave"), true); |
| callTraces[i].clear(); |
| } |
| |
| //save all dirty editors with resource that IS NOT a parent |
| // of the contents of the dirty editors without confirmation, this should not |
| // save any as they are not parented by the resource provided |
| for (int i = 0; i < total; i++) |
| mocks[i].setDirty(true); |
| assertEquals(IDE.saveAllEditors(new IResource[] {}, false), true); |
| for (int i = 0; i < total; i++) { |
| // the editors were not in the empty project hence still dirty |
| assertEquals(mocks[i].isDirty(), true); |
| callTraces[i].clear(); |
| } |
| |
| // clear the dirty state so the tearDown does not open a confirm dialog. |
| for (int i = 0; i < total; i++) |
| mocks[i].setDirty(false); |
| } |
| |
| public void testSaveAllEditors() throws Throwable { |
| int total = 3; |
| |
| final IFile[] files = new IFile[total]; |
| IEditorPart[] editors = new IEditorPart[total]; |
| CallHistory[] callTraces = new CallHistory[total]; |
| MockEditorPart[] mocks = new MockEditorPart[total]; |
| |
| proj = FileUtil.createProject("testOpenEditor"); |
| for (int i = 0; i < total; i++) { |
| files[i] = FileUtil.createFile(i + ".mock2", proj); |
| editors[i] = IDE.openEditor(fActivePage, files[i]); |
| mocks[i] = (MockEditorPart) editors[i]; |
| callTraces[i] = mocks[i].getCallHistory(); |
| } |
| |
| /* |
| javadoc: If there are no dirty editors this method returns without effect. |
| javadoc: If confirm is true the user is prompted to confirm the command |
| */ |
| //save all clean editors with confirmation |
| assertEquals(fActivePage.saveAllEditors(true), true); |
| for (int i = 0; i < total; i++) { |
| assertEquals(callTraces[i].contains("isDirty"), true); |
| assertEquals(callTraces[i].contains("doSave"), false); |
| callTraces[i].clear(); |
| } |
| |
| //save all dirty editors with confirmation can't be tested |
| |
| /* |
| javadoc: Parameters: confirm - false to save unsaved changes without asking |
| */ |
| //save all clean editors without confirmation |
| assertEquals(fActivePage.saveAllEditors(false), true); |
| for (int i = 0; i < total; i++) { |
| assertEquals(callTraces[i].contains("isDirty"), true); |
| assertEquals(callTraces[i].contains("doSave"), false); |
| callTraces[i].clear(); |
| } |
| |
| //save all dirty editors without confirmation |
| for (int i = 0; i < total; i++) |
| mocks[i].setDirty(true); |
| assertEquals(fActivePage.saveAllEditors(false), true); |
| for (int i = 0; i < total; i++) |
| assertEquals(callTraces[i].verifyOrder(new String[] { "isDirty", |
| "doSave" }), true); |
| } |
| |
| public void testGetEditors() throws Throwable { |
| proj = FileUtil.createProject("testOpenEditor"); |
| int totalBefore = fActivePage.getEditorReferences().length; |
| int num = 3; |
| IEditorPart[] editors = new IEditorPart[num]; |
| |
| for (int i = 0; i < num; i++) { |
| editors[i] = IDE.openEditor(fActivePage, FileUtil.createFile(i |
| + ".mock2", proj)); |
| assertEquals(hasEditor(editors[i]), true); |
| } |
| assertEquals(fActivePage.getEditorReferences().length, totalBefore |
| + num); |
| |
| fActivePage.closeEditor(editors[0], false); |
| assertEquals(hasEditor(editors[0]), false); |
| assertEquals(fActivePage.getEditorReferences().length, totalBefore |
| + num - 1); |
| |
| fActivePage.closeAllEditors(false); |
| assertEquals(fActivePage.getEditorReferences().length, 0); |
| } |
| |
| public void testShowActionSet() { |
| String id = MockActionDelegate.ACTION_SET_ID; |
| WorkbenchPage page = (WorkbenchPage) fActivePage; |
| |
| int totalBefore = page.getActionSets().length; |
| fActivePage.showActionSet(id); |
| |
| IActionSetDescriptor[] sets = ((WorkbenchPage) fActivePage) |
| .getActionSets(); |
| boolean found = false; |
| for (int i = 0; i < sets.length; i++) |
| if (id.equals(sets[i].getId())) |
| found = true; |
| assertEquals(found, true); |
| |
| //check that the method does not add an invalid action set to itself |
| id = IConstants.FakeID; |
| fActivePage.showActionSet(id); |
| |
| sets = ((WorkbenchPage) fActivePage).getActionSets(); |
| found = false; |
| for (int i = 0; i < sets.length; i++) |
| if (id.equals(sets[i].getId())) |
| found = true; |
| assertEquals(found, false); |
| assertEquals(page.getActionSets().length, totalBefore + 1); |
| } |
| |
| public void testHideActionSet() { |
| WorkbenchPage page = (WorkbenchPage) fActivePage; |
| int totalBefore = page.getActionSets().length; |
| |
| String id = MockWorkbenchWindowActionDelegate.SET_ID; |
| fActivePage.showActionSet(id); |
| assertEquals(page.getActionSets().length, totalBefore + 1); |
| |
| fActivePage.hideActionSet(id); |
| assertEquals(page.getActionSets().length, totalBefore); |
| |
| IActionSetDescriptor[] sets = page.getActionSets(); |
| boolean found = false; |
| for (int i = 0; i < sets.length; i++) |
| if (id.equals(sets[i].getId())) |
| found = true; |
| assertEquals(found, false); |
| } |
| |
| /** |
| * Return whether or not the editor exists in the current page. |
| * @param editor |
| * @return boolean |
| */ |
| private boolean hasEditor(IEditorPart editor) { |
| IEditorReference[] references = fActivePage.getEditorReferences(); |
| for (int i = 0; i < references.length; i++) { |
| if (references[i].getEditor(false).equals(editor)) |
| return true; |
| } |
| return false; |
| } |
| |
| /** |
| * Return whether or not the view exists in the current page. |
| * @param editor |
| * @return boolean |
| */ |
| private boolean hasView(IViewPart view) { |
| IViewReference[] references = fActivePage.getViewReferences(); |
| for (int i = 0; i < references.length; i++) { |
| if (references[i].getView(false).equals(view)) |
| return true; |
| } |
| return false; |
| } |
| |
| public void testStackOrder() { |
| WorkbenchPage page = (WorkbenchPage) fActivePage; |
| try { |
| IViewPart part1 = page.showView(MockViewPart.ID); |
| IViewPart part2 = page.showView(MockViewPart.ID2); |
| IViewPart part3 = page.showView(MockViewPart.ID3); |
| IViewPart part4 = page.showView(MockViewPart.ID4); |
| |
| IViewPart[] stack = page.getViewStack(part1); |
| assertTrue(stack.length == 4); |
| assertTrue(stack[0] == part4); |
| assertTrue(stack[1] == part3); |
| assertTrue(stack[2] == part2); |
| assertTrue(stack[3] == part1); |
| |
| page.activate(part2); |
| stack = page.getViewStack(part1); |
| assertTrue(stack.length == 4); |
| assertTrue(stack[0] == part2); |
| assertTrue(stack[1] == part4); |
| assertTrue(stack[2] == part3); |
| assertTrue(stack[3] == part1); |
| |
| page.activate(part1); |
| stack = page.getViewStack(part1); |
| assertTrue(stack.length == 4); |
| assertTrue(stack[0] == part1); |
| assertTrue(stack[1] == part2); |
| assertTrue(stack[2] == part4); |
| assertTrue(stack[3] == part3); |
| |
| page.activate(part3); |
| stack = page.getViewStack(part1); |
| assertTrue(stack.length == 4); |
| assertTrue(stack[0] == part3); |
| assertTrue(stack[1] == part1); |
| assertTrue(stack[2] == part2); |
| assertTrue(stack[3] == part4); |
| } catch (PartInitException e) { |
| fail(e.getMessage()); |
| } |
| } |
| |
| /** |
| * Test the VIEW_CREATE parameter for showView. Ensures that the created |
| * view is not the active part. |
| * |
| */ |
| public void testView_CREATE1() { |
| WorkbenchPage page = (WorkbenchPage) fActivePage; |
| try { |
| |
| page.setPerspective(WorkbenchPlugin.getDefault() |
| .getPerspectiveRegistry().findPerspectiveWithId( |
| "org.eclipse.ui.tests.api.ViewPerspective")); |
| |
| //create a part to be active |
| IViewPart activePart = page.showView(MockViewPart.ID); |
| IViewPart createdPart = page.showView(MockViewPart.ID2, null, |
| IWorkbenchPage.VIEW_CREATE); |
| |
| IViewPart[] stack = page.getViewStack(activePart); |
| assertEquals(2, stack.length); |
| |
| assertEquals(activePart, stack[0]); |
| assertEquals(createdPart, stack[1]); |
| |
| assertFalse(page.isPartVisible(createdPart)); |
| |
| assertEquals(activePart, page.getActivePart()); |
| } catch (PartInitException e) { |
| fail(e.getMessage()); |
| } |
| } |
| |
| /** |
| * Test the VIEW_CREATE parameter for showView. Ensures that the created |
| * view is not the active part and is not visible |
| */ |
| public void testView_CREATE2() { |
| WorkbenchPage page = (WorkbenchPage) fActivePage; |
| try { |
| |
| page.setPerspective(WorkbenchPlugin.getDefault() |
| .getPerspectiveRegistry().findPerspectiveWithId( |
| "org.eclipse.ui.tests.api.ViewPerspective")); |
| |
| //create a part to be active |
| IViewPart activePart = page.showView(MockViewPart.ID3); |
| IViewPart createdPart = page.showView(MockViewPart.ID2, null, |
| IWorkbenchPage.VIEW_CREATE); |
| |
| IViewPart[] stack = page.getViewStack(createdPart); |
| assertEquals(2, stack.length); |
| |
| assertEquals(page.findView(MockViewPart.ID), stack[0]); |
| assertEquals(createdPart, stack[1]); |
| |
| assertFalse(page.isPartVisible(createdPart)); |
| |
| assertEquals(activePart, page.getActivePart()); |
| } catch (PartInitException e) { |
| fail(e.getMessage()); |
| } |
| } |
| |
| /** |
| * Test the VIEW_CREATE parameter for showView. Ensures that the created |
| * view is not the active part and is visible. |
| */ |
| public void testView_CREATE3() { |
| WorkbenchPage page = (WorkbenchPage) fActivePage; |
| try { |
| |
| page.setPerspective(WorkbenchPlugin.getDefault() |
| .getPerspectiveRegistry().findPerspectiveWithId( |
| "org.eclipse.ui.tests.api.ViewPerspective")); |
| |
| //create a part to be active |
| IViewPart activePart = page.showView(MockViewPart.ID3); |
| IViewPart createdPart = page.showView(MockViewPart.ID4, null, |
| IWorkbenchPage.VIEW_CREATE); |
| |
| IViewPart[] stack = page.getViewStack(createdPart); |
| assertEquals(1, stack.length); |
| |
| assertEquals(createdPart, stack[0]); |
| |
| assertTrue(page.isPartVisible(createdPart)); |
| |
| assertEquals(activePart, page.getActivePart()); |
| } catch (PartInitException e) { |
| fail(e.getMessage()); |
| } |
| } |
| |
| /** |
| * Test the VIEW_VISIBLE parameter for showView, opening the view in the |
| * stack containing the active view. Ensures that the created view is not |
| * the active part and is not visible. |
| */ |
| public void testView_VISIBLE1() { |
| WorkbenchPage page = (WorkbenchPage) fActivePage; |
| try { |
| page.setPerspective(WorkbenchPlugin.getDefault() |
| .getPerspectiveRegistry().findPerspectiveWithId( |
| "org.eclipse.ui.tests.api.ViewPerspective")); |
| |
| //create a part to be active |
| IViewPart activePart = page.showView(MockViewPart.ID); |
| IViewPart createdPart = page.showView(MockViewPart.ID2, null, |
| IWorkbenchPage.VIEW_VISIBLE); |
| IViewPart[] stack = page.getViewStack(activePart); |
| assertEquals(2, stack.length); |
| |
| assertEquals(activePart, stack[0]); |
| assertEquals(createdPart, stack[1]); |
| |
| assertFalse(page.isPartVisible(createdPart)); |
| |
| assertEquals(activePart, page.getActivePart()); |
| } catch (PartInitException e) { |
| fail(e.getMessage()); |
| } |
| } |
| |
| /** |
| * Test the VIEW_VISIBLE parameter for showView, opening the view in its |
| * own stack. Ensures that the created view is not active part but is the |
| * top part in its stack. |
| */ |
| public void testView_VISIBLE3() { |
| WorkbenchPage page = (WorkbenchPage) fActivePage; |
| try { |
| page.setPerspective(WorkbenchPlugin.getDefault() |
| .getPerspectiveRegistry().findPerspectiveWithId( |
| "org.eclipse.ui.tests.api.ViewPerspective")); |
| |
| //create a part to be active |
| IViewPart activePart = page.showView(MockViewPart.ID3); |
| |
| IViewPart createdPart = page.showView(MockViewPart.ID4, null, |
| IWorkbenchPage.VIEW_VISIBLE); |
| IViewPart[] stack = page.getViewStack(createdPart); |
| assertEquals(1, stack.length); |
| |
| assertEquals(createdPart, stack[0]); |
| |
| assertTrue(page.isPartVisible(createdPart)); |
| |
| assertEquals(activePart, page.getActivePart()); |
| } catch (PartInitException e) { |
| fail(e.getMessage()); |
| } |
| } |
| |
| /** |
| * Test opening a perspective with a fast view. |
| */ |
| public void testOpenPerspectiveWithFastView() { |
| WorkbenchPage page = (WorkbenchPage) fActivePage; |
| |
| try { |
| fWin.getWorkbench().showPerspective( |
| PerspectiveWithFastView.PERSP_ID, fWin); |
| } catch (WorkbenchException e) { |
| fail("Unexpected WorkbenchException: " + e); |
| } |
| |
| assertEquals(page.getFastViews().length, 1); |
| assertEquals(page.getFastViews()[0].getId(), |
| "org.eclipse.ui.views.ResourceNavigator"); |
| assertEquals(page.getViewReferences().length, 1); |
| assertTrue(page.getViewReferences()[0].isFastView()); |
| |
| ClosePerspectiveAction closePespective = new ClosePerspectiveAction( |
| fWin); |
| closePespective.run(); |
| |
| } |
| |
| /** |
| * Test opening a perspective with placeholders for multi instance views. |
| * The placeholders are added at top level (not in any folder). |
| * |
| * @since 3.1 |
| */ |
| public void testOpenPerspectiveWithMultiViewPlaceholdersAtTopLevel() { |
| WorkbenchPage page = (WorkbenchPage) fActivePage; |
| |
| try { |
| fWin.getWorkbench().showPerspective( |
| PerspectiveWithMultiViewPlaceholdersAtTopLevel.PERSP_ID, fWin); |
| } catch (WorkbenchException e) { |
| fail("Unexpected WorkbenchException: " + e); |
| } |
| |
| PerspectiveState state = new PerspectiveState(page); |
| ArrayList partIds = state.getPartIds(null); |
| assertTrue(partIds.contains("*")); |
| assertTrue(partIds.contains(MockViewPart.IDMULT)); |
| assertTrue(partIds.contains(MockViewPart.IDMULT + ":secondaryId")); |
| assertTrue(partIds.contains(MockViewPart.IDMULT + ":*")); |
| } |
| |
| /** |
| * Test opening a perspective with placeholders for multi instance views. |
| * The placeholders are added in a placeholder folder. |
| * This is a regression test for bug 72383 [Perspectives] Placeholder folder error with multiple instance views |
| * |
| * @since 3.1 |
| */ |
| public void testOpenPerspectiveWithMultiViewPlaceholdersInPlaceholderFolder() { |
| WorkbenchPage page = (WorkbenchPage) fActivePage; |
| |
| try { |
| fWin.getWorkbench().showPerspective( |
| PerspectiveWithMultiViewPlaceholdersInPlaceholderFolder.PERSP_ID, fWin); |
| } catch (WorkbenchException e) { |
| fail("Unexpected WorkbenchException: " + e); |
| } |
| |
| PerspectiveState state = new PerspectiveState(page); |
| ArrayList partIds = state.getPartIds("placeholderFolder"); |
| assertTrue(partIds.contains("*")); |
| assertTrue(partIds.contains(MockViewPart.IDMULT)); |
| assertTrue(partIds.contains(MockViewPart.IDMULT + ":secondaryId")); |
| assertTrue(partIds.contains(MockViewPart.IDMULT + ":*")); |
| } |
| |
| /** |
| * Test opening a perspective with placeholders for multi instance views. |
| * The placeholders are added at top level (not in any folder). |
| * |
| * @since 3.1 |
| */ |
| public void testOpenPerspectiveWithMultiViewPlaceholdersInFolder() { |
| WorkbenchPage page = (WorkbenchPage) fActivePage; |
| |
| try { |
| fWin.getWorkbench().showPerspective( |
| PerspectiveWithMultiViewPlaceholdersInFolder.PERSP_ID, fWin); |
| } catch (WorkbenchException e) { |
| fail("Unexpected WorkbenchException: " + e); |
| } |
| |
| PerspectiveState state = new PerspectiveState(page); |
| ArrayList partIds = state.getPartIds("folder"); |
| assertTrue(partIds.contains("*")); |
| assertTrue(partIds.contains(MockViewPart.IDMULT)); |
| assertTrue(partIds.contains(MockViewPart.IDMULT + ":secondaryId")); |
| assertTrue(partIds.contains(MockViewPart.IDMULT + ":*")); |
| } |
| |
| /** |
| * Tests the getNewWizardShortcuts() method. |
| * |
| * @since 3.1 |
| */ |
| public void testGetNewWizardShortcuts() { |
| String[] shortcuts = fActivePage.getNewWizardShortcuts(); |
| assertNotNull(shortcuts); |
| assertEquals(0, shortcuts.length); |
| |
| IWorkbenchWindow win = openTestWindow(IDE.RESOURCE_PERSPECTIVE_ID); |
| IWorkbenchPage page = win.getActivePage(); |
| shortcuts = page.getNewWizardShortcuts(); |
| List shortcutList = Arrays.asList(shortcuts); |
| assertTrue(shortcutList.contains("org.eclipse.ui.wizards.new.folder")); |
| assertTrue(shortcutList.contains("org.eclipse.ui.wizards.new.file")); |
| } |
| |
| /** |
| * Tests the getShowViewShortcuts() method. |
| * |
| * @since 3.1 |
| */ |
| public void testGetShowViewShortcuts() { |
| String[] shortcuts = fActivePage.getShowViewShortcuts(); |
| assertNotNull(shortcuts); |
| assertEquals(0, shortcuts.length); |
| |
| IWorkbenchWindow win = openTestWindow(IDE.RESOURCE_PERSPECTIVE_ID); |
| IWorkbenchPage page = win.getActivePage(); |
| shortcuts = page.getShowViewShortcuts(); |
| List shortcutList = Arrays.asList(shortcuts); |
| assertTrue(shortcutList.contains(IPageLayout.ID_RES_NAV)); |
| assertTrue(shortcutList.contains(IPageLayout.ID_OUTLINE)); |
| assertTrue(shortcutList.contains(IPageLayout.ID_PROP_SHEET)); |
| assertTrue(shortcutList.contains(IPageLayout.ID_PROBLEM_VIEW)); |
| } |
| |
| /** |
| * Tests the getPerspectiveShortcuts() method. |
| * |
| * @since 3.1 |
| */ |
| public void testGetPerspectiveShortcuts() { |
| String[] shortcuts = fActivePage.getPerspectiveShortcuts(); |
| assertNotNull(shortcuts); |
| assertEquals(0, shortcuts.length); |
| // not much of a test |
| } |
| |
| /** |
| * Tests the getOpenPerspectives() method. |
| * |
| * @since 3.1 |
| */ |
| public void testGetOpenPerspectives() { |
| IPerspectiveDescriptor[] openPersps = fActivePage.getOpenPerspectives(); |
| assertEquals(1, openPersps.length); |
| assertEquals(EmptyPerspective.PERSP_ID, openPersps[0].getId()); |
| |
| IPerspectiveRegistry reg = fWorkbench.getPerspectiveRegistry(); |
| IPerspectiveDescriptor resourcePersp = reg.findPerspectiveWithId(IDE.RESOURCE_PERSPECTIVE_ID); |
| fActivePage.setPerspective(resourcePersp); |
| openPersps = fActivePage.getOpenPerspectives(); |
| assertEquals(2, openPersps.length); |
| assertEquals(EmptyPerspective.PERSP_ID, openPersps[0].getId()); |
| assertEquals(IDE.RESOURCE_PERSPECTIVE_ID, openPersps[1].getId()); |
| |
| IPerspectiveDescriptor emptyPersp = reg.findPerspectiveWithId(EmptyPerspective.PERSP_ID); |
| fActivePage.setPerspective(emptyPersp); |
| openPersps = fActivePage.getOpenPerspectives(); |
| assertEquals(2, openPersps.length); |
| assertEquals(EmptyPerspective.PERSP_ID, openPersps[0].getId()); |
| assertEquals(IDE.RESOURCE_PERSPECTIVE_ID, openPersps[1].getId()); |
| |
| fActivePage.closeAllPerspectives(false, false); |
| openPersps = fActivePage.getOpenPerspectives(); |
| assertEquals(0, openPersps.length); |
| |
| fActivePage.close(); |
| openPersps = fActivePage.getOpenPerspectives(); |
| assertEquals(0, openPersps.length); |
| } |
| |
| /** |
| * Tests the getSortedPerspectives() method. |
| * |
| * @since 3.1 |
| */ |
| public void testGetSortedPerspectives() { |
| IPerspectiveDescriptor[] openPersps = fActivePage.getSortedPerspectives(); |
| assertEquals(1, openPersps.length); |
| assertEquals(EmptyPerspective.PERSP_ID, openPersps[0].getId()); |
| |
| IPerspectiveRegistry reg = fWorkbench.getPerspectiveRegistry(); |
| IPerspectiveDescriptor resourcePersp = reg.findPerspectiveWithId(IDE.RESOURCE_PERSPECTIVE_ID); |
| fActivePage.setPerspective(resourcePersp); |
| openPersps = fActivePage.getSortedPerspectives(); |
| assertEquals(2, openPersps.length); |
| assertEquals(EmptyPerspective.PERSP_ID, openPersps[0].getId()); |
| assertEquals(IDE.RESOURCE_PERSPECTIVE_ID, openPersps[1].getId()); |
| |
| IPerspectiveDescriptor emptyPersp = reg.findPerspectiveWithId(EmptyPerspective.PERSP_ID); |
| fActivePage.setPerspective(emptyPersp); |
| openPersps = fActivePage.getSortedPerspectives(); |
| assertEquals(2, openPersps.length); |
| assertEquals(IDE.RESOURCE_PERSPECTIVE_ID, openPersps[0].getId()); |
| assertEquals(EmptyPerspective.PERSP_ID, openPersps[1].getId()); |
| |
| fActivePage.closeAllPerspectives(false, false); |
| openPersps = fActivePage.getSortedPerspectives(); |
| assertEquals(0, openPersps.length); |
| |
| fActivePage.close(); |
| openPersps = fActivePage.getSortedPerspectives(); |
| assertEquals(0, openPersps.length); |
| } |
| |
| /** |
| * Tests the closePerspective method. |
| * |
| * @since 3.1 |
| */ |
| public void testClosePerspective() { |
| // TODO: Need to test variants with saveEditors==true |
| |
| IPerspectiveRegistry reg = fWorkbench.getPerspectiveRegistry(); |
| IPerspectiveDescriptor emptyPersp = reg.findPerspectiveWithId(EmptyPerspective.PERSP_ID); |
| IPerspectiveDescriptor resourcePersp = reg.findPerspectiveWithId(IDE.RESOURCE_PERSPECTIVE_ID); |
| |
| fActivePage.setPerspective(resourcePersp); |
| IPerspectiveDescriptor[] openPersps = fActivePage.getOpenPerspectives(); |
| assertEquals(2, openPersps.length); |
| |
| fActivePage.closePerspective(resourcePersp, false, false); |
| openPersps = fActivePage.getOpenPerspectives(); |
| assertEquals(1, openPersps.length); |
| assertEquals(EmptyPerspective.PERSP_ID, openPersps[0].getId()); |
| |
| fActivePage.closePerspective(emptyPersp, false, false); |
| assertEquals(fActivePage, fWin.getActivePage()); // page not closed |
| openPersps = fActivePage.getOpenPerspectives(); |
| assertEquals(0, openPersps.length); |
| |
| fActivePage.setPerspective(emptyPersp); |
| openPersps = fActivePage.getOpenPerspectives(); |
| assertEquals(1, openPersps.length); |
| |
| fActivePage.closePerspective(emptyPersp, false, true); |
| openPersps = fActivePage.getOpenPerspectives(); |
| assertEquals(0, openPersps.length); |
| assertNull(fWin.getActivePage()); // page closed |
| } |
| |
| /** |
| * Tests the closeAllPerspectives method. |
| * |
| * @since 3.1 |
| */ |
| public void testCloseAllPerspectives() { |
| // TODO: Need to test variants with saveEditors==true |
| |
| IPerspectiveRegistry reg = fWorkbench.getPerspectiveRegistry(); |
| IPerspectiveDescriptor emptyPersp = reg.findPerspectiveWithId(EmptyPerspective.PERSP_ID); |
| IPerspectiveDescriptor resourcePersp = reg.findPerspectiveWithId(IDE.RESOURCE_PERSPECTIVE_ID); |
| |
| fActivePage.setPerspective(resourcePersp); |
| IPerspectiveDescriptor[] openPersps = fActivePage.getOpenPerspectives(); |
| assertEquals(2, openPersps.length); |
| |
| fActivePage.closeAllPerspectives(false, false); |
| assertEquals(fActivePage, fWin.getActivePage()); // page not closed |
| openPersps = fActivePage.getOpenPerspectives(); |
| assertEquals(0, openPersps.length); |
| |
| fActivePage.setPerspective(emptyPersp); |
| openPersps = fActivePage.getOpenPerspectives(); |
| assertEquals(1, openPersps.length); |
| |
| fActivePage.closeAllPerspectives(false, true); |
| openPersps = fActivePage.getOpenPerspectives(); |
| assertEquals(0, openPersps.length); |
| assertNull(fWin.getActivePage()); // page closed |
| } |
| |
| /** |
| * Regression test for Bug 76285 [Presentations] Folder tab does not indicate current view. |
| * Tests that, when switching between perspectives, the remembered old part correctly |
| * handles multi-view instances. |
| */ |
| public void testBug76285() { |
| IWorkbenchPage page = fActivePage; |
| IPerspectiveDescriptor originalPersp = page.getPerspective(); |
| IPerspectiveDescriptor resourcePersp = PlatformUI.getWorkbench() |
| .getPerspectiveRegistry().findPerspectiveWithId( |
| IDE.RESOURCE_PERSPECTIVE_ID); |
| // test requires switching between two different perspectives |
| assertNotSame(originalPersp, resourcePersp); |
| |
| int n = 5; |
| IViewPart[] views = new IViewPart[n]; |
| for (int i = 0; i < n; ++i) { |
| try { |
| views[i] = page.showView(MockViewPart.IDMULT, Integer |
| .toString(i), IWorkbenchPage.VIEW_CREATE); |
| } catch (PartInitException e) { |
| fail(e.getMessage()); |
| } |
| } |
| assertEquals(5, page.getViews().length); |
| for (int i = 0; i < n; ++i) { |
| page.activate(views[i]); |
| page.setPerspective(resourcePersp); |
| assertFalse(page.getActivePart() instanceof MockViewPart); |
| page.setPerspective(originalPersp); |
| assertEquals(views[i], page.getActivePart()); |
| } |
| } |
| |
| /** |
| * Tests that IShowEditorInput.showEditorInput is called when a |
| * matching editor is found during openEditor, and is not called |
| * when a new editor is opened. |
| * |
| * @since 3.1 |
| */ |
| public void testShowEditorInput() throws Exception { |
| IWorkbenchPage page = fActivePage; |
| proj = FileUtil.createProject("testShowEditorInput"); |
| IFile file = FileUtil.createFile("a.mock1", proj); |
| MockEditorPart part1 = (MockEditorPart) IDE.openEditor(page, file); |
| assertFalse(part1.getCallHistory().contains("showEditorInput")); |
| |
| MockEditorPart part2 = (MockEditorPart) IDE.openEditor(page, file); |
| assertTrue(part1 == part2); |
| assertTrue(part2.getCallHistory().contains("showEditorInput")); |
| } |
| |
| /** |
| * Tests that the openEditor and findEditor variants that accepts match flags work as expected. |
| * |
| * @since 3.2 |
| */ |
| public void testOpenAndFindEditorWithMatchFlags() throws Exception { |
| IWorkbenchPage page = fActivePage; |
| proj = FileUtil.createProject("testOpenEditorMatchFlags"); |
| IFile file1 = FileUtil.createFile("a.mock1", proj); |
| IFile file2 = FileUtil.createFile("a.mock2", proj); |
| FileEditorInput input1 = new FileEditorInput(file1); |
| FileEditorInput input2 = new FileEditorInput(file2); |
| String id1 = MockEditorPart.ID1; |
| String id2 = MockEditorPart.ID2; |
| |
| // first editor (no match) |
| MockEditorPart part1 = (MockEditorPart) page.openEditor(input1, id1, true, IWorkbenchPage.MATCH_INPUT); |
| assertNotNull(part1); |
| |
| // same input, same id, matching input (should match part1) |
| MockEditorPart part2 = (MockEditorPart) page.openEditor(input1, id1, true, IWorkbenchPage.MATCH_INPUT); |
| assertTrue(part1 == part2); |
| |
| // same input, different id, matching input (should match part1) |
| MockEditorPart part3 = (MockEditorPart) page.openEditor(input1, id2, true, IWorkbenchPage.MATCH_INPUT); |
| assertTrue(part1 == part3); |
| |
| // same input, different id, matching input and id (no match) |
| MockEditorPart part4 = (MockEditorPart) page.openEditor(input1, id2, true, IWorkbenchPage.MATCH_INPUT | IWorkbenchPage.MATCH_ID); |
| assertNotNull(part4); |
| assertTrue(part4 != part1); |
| |
| // same input, same id, matching nothing (no match) |
| MockEditorPart part5 = (MockEditorPart) page.openEditor(input1, id1, true, IWorkbenchPage.MATCH_NONE); |
| assertNotNull(part5); |
| assertTrue(part5 != part1); |
| assertTrue(part5 != part4); |
| |
| // different input, same id, matching id (should match part5 instead of part1, because it was active) |
| MockEditorPart part6 = (MockEditorPart) page.openEditor(input2, id1, true, IWorkbenchPage.MATCH_ID); |
| assertTrue(part6 == part5); |
| |
| // different input, different id, matching input and id (no match) |
| MockEditorPart part7 = (MockEditorPart) page.openEditor(input2, id2, true, IWorkbenchPage.MATCH_INPUT | IWorkbenchPage.MATCH_ID); |
| assertNotNull(part7); |
| assertTrue(part7 != part1); |
| assertTrue(part7 != part4); |
| assertTrue(part7 != part5); |
| |
| // At this point, there are 4 editors open: |
| // part1 (input1, id1), part4 (input1, id2), part5 (input1, id1), and part7 (input2, id2). |
| // with part7 active. |
| |
| // find with MATCH_NONE is always empty |
| IEditorReference[] refs = page.findEditors(input1, id1, IWorkbenchPage.MATCH_NONE); |
| assertEquals(0, refs.length); |
| |
| // find input1 with MATCH_INPUT finds 3 editors: part1, part4 and part5 (in order) |
| refs = page.findEditors(input1, null, IWorkbenchPage.MATCH_INPUT); |
| assertEquals(3, refs.length); |
| assertEquals(part1, refs[0].getPart(true)); |
| assertEquals(part4, refs[1].getPart(true)); |
| assertEquals(part5, refs[2].getPart(true)); |
| |
| // find input2 with MATCH_INPUT finds 1 editor: part7 |
| refs = page.findEditors(input2, null, IWorkbenchPage.MATCH_INPUT); |
| assertEquals(1, refs.length); |
| assertEquals(part7, refs[0].getPart(true)); |
| |
| // find id1 with MATCH_ID finds 2 editors: part1 and part5 (in order) |
| refs = page.findEditors(null, id1, IWorkbenchPage.MATCH_ID); |
| assertEquals(2, refs.length); |
| assertEquals(part1, refs[0].getPart(true)); |
| assertEquals(part5, refs[1].getPart(true)); |
| |
| // find id2 with MATCH_ID finds 2 editors: part4 and part7 (with part7 first because it was active) |
| refs = page.findEditors(null, id2, IWorkbenchPage.MATCH_ID); |
| assertEquals(2, refs.length); |
| assertEquals(part7, refs[0].getPart(true)); |
| assertEquals(part4, refs[1].getPart(true)); |
| |
| // find input1 and id1 with MATCH_INPUT and MATCH_ID finds 2 editors: part1 and part5 (in order) |
| refs = page.findEditors(input1, id1, IWorkbenchPage.MATCH_INPUT | IWorkbenchPage.MATCH_ID); |
| assertEquals(2, refs.length); |
| assertEquals(part1, refs[0].getPart(true)); |
| assertEquals(part5, refs[1].getPart(true)); |
| |
| // find input1 and id2 with MATCH_INPUT and MATCH_ID finds 1 editors: part4 |
| refs = page.findEditors(input1, id2, IWorkbenchPage.MATCH_INPUT | IWorkbenchPage.MATCH_ID); |
| assertEquals(1, refs.length); |
| assertEquals(part4, refs[0].getPart(true)); |
| } |
| } |
