← Back to branch summary

~ubuntu-branches/debian/sid/eclipse-cdt/sid

« back to all changes in this revision

Viewing changes to results/plugins/org.eclipse.cdt.ui.tests/ui/org/eclipse/cdt/ui/tests/BaseUITestCase.java

  • Committer: Package Import Robot
  • Author(s): Jakub Adam
  • Date: 2011-10-06 21:15:04 UTC
  • mfrom: (1.1.4)
  • Revision ID: package-import@ubuntu.com-20111006211504-8dutmljjih0zikfv
Tags: 8.0.1-1
* New upstream release.
* Split the JNI packages into a separate architecture dependent
  package and made eclipse-cdt architecture independent.
* Install JNI libraries into multiarch aware location
* Bumped Standards-Version to 3.9.2.

Show diffs side-by-side

added added

removed removed

Lines of Context:
results/plugins/org.eclipse.cdt.ui.tests/ui/org/eclipse/cdt/ui/tests/BaseUITestCase.java
1
 
/*******************************************************************************
2
 
 * Copyright (c) 2006, 2009 Wind River Systems, Inc. and others.
3
 
 * All rights reserved. This program and the accompanying materials
4
 
 * are made available under the terms of the Eclipse Public License v1.0
5
 
 * which accompanies this distribution, and is available at
6
 
 * http://www.eclipse.org/legal/epl-v10.html
7
 
 *
8
 
 * Contributors:
9
 
 *    Markus Schorn - initial API and implementation
10
 
 *******************************************************************************/ 
11
 
package org.eclipse.cdt.ui.tests;
12
 
 
13
 
import java.io.IOException;
14
 
import java.util.ArrayList;
15
 
import java.util.List;
16
 
 
17
 
import org.eclipse.core.commands.ExecutionException;
18
 
import org.eclipse.core.commands.NotEnabledException;
19
 
import org.eclipse.core.commands.NotHandledException;
20
 
import org.eclipse.core.commands.common.NotDefinedException;
21
 
import org.eclipse.core.resources.IContainer;
22
 
import org.eclipse.core.resources.IFile;
23
 
import org.eclipse.core.runtime.CoreException;
24
 
import org.eclipse.core.runtime.Path;
25
 
import org.eclipse.swt.SWT;
26
 
import org.eclipse.swt.SWTException;
27
 
import org.eclipse.swt.widgets.Composite;
28
 
import org.eclipse.swt.widgets.Control;
29
 
import org.eclipse.swt.widgets.Display;
30
 
import org.eclipse.swt.widgets.Event;
31
 
import org.eclipse.swt.widgets.Tree;
32
 
import org.eclipse.swt.widgets.TreeItem;
33
 
import org.eclipse.ui.IEditorPart;
34
 
import org.eclipse.ui.IEditorReference;
35
 
import org.eclipse.ui.IViewPart;
36
 
import org.eclipse.ui.IViewReference;
37
 
import org.eclipse.ui.IWorkbenchPage;
38
 
import org.eclipse.ui.IWorkbenchPartSite;
39
 
import org.eclipse.ui.IWorkbenchWindow;
40
 
import org.eclipse.ui.PartInitException;
41
 
import org.eclipse.ui.PlatformUI;
42
 
import org.eclipse.ui.WorkbenchException;
43
 
import org.eclipse.ui.handlers.IHandlerService;
44
 
 
45
 
import org.eclipse.cdt.core.CCorePlugin;
46
 
import org.eclipse.cdt.core.dom.ILinkage;
47
 
import org.eclipse.cdt.core.dom.ast.IASTTranslationUnit;
48
 
import org.eclipse.cdt.core.index.IIndex;
49
 
import org.eclipse.cdt.core.index.IIndexFile;
50
 
import org.eclipse.cdt.core.index.IndexLocationFactory;
51
 
import org.eclipse.cdt.core.model.CModelException;
52
 
import org.eclipse.cdt.core.model.CoreModel;
53
 
import org.eclipse.cdt.core.model.ICProject;
54
 
import org.eclipse.cdt.core.testplugin.util.BaseTestCase;
55
 
import org.eclipse.cdt.core.testplugin.util.TestSourceReader;
56
 
import org.eclipse.cdt.ui.testplugin.CTestPlugin;
57
 
import org.eclipse.cdt.ui.testplugin.util.StringAsserts;
58
 
 
59
 
public class BaseUITestCase extends BaseTestCase {
60
 
        
61
 
        public BaseUITestCase() {
62
 
                super();
63
 
        }
64
 
        
65
 
        public BaseUITestCase(String name) {
66
 
                super(name);
67
 
        }
68
 
        
69
 
        /* (non-Javadoc)
70
 
         * @see org.eclipse.cdt.core.testplugin.util.BaseTestCase#setUp()
71
 
         */
72
 
        @Override
73
 
        protected void setUp() throws Exception {
74
 
                super.setUp();
75
 
                final IWorkbenchPage activePage = PlatformUI.getWorkbench().getActiveWorkbenchWindow().getActivePage();
76
 
                IViewPart view= activePage.findView("org.eclipse.cdt.ui.tests.DOMAST.DOMAST");
77
 
                if (view != null) {
78
 
                        activePage.hideView(view);
79
 
                }
80
 
        }
81
 
 
82
 
        /* (non-Javadoc)
83
 
         * @see org.eclipse.cdt.core.testplugin.util.BaseTestCase#tearDown()
84
 
         */
85
 
        @Override
86
 
        protected void tearDown() throws Exception {
87
 
                runEventQueue(0);
88
 
                super.tearDown();
89
 
        }
90
 
 
91
 
        /**
92
 
         * Reads a section in comments form the source of the given class. Fully 
93
 
         * equivalent to <code>readTaggedComment(getClass(), tag)</code>
94
 
         * @since 4.0
95
 
         */
96
 
    protected String readTaggedComment(final String tag) throws IOException {
97
 
        return TestSourceReader.readTaggedComment(CTestPlugin.getDefault().getBundle(), "ui", getClass(), tag);
98
 
    }
99
 
 
100
 
    /**
101
 
     * Reads multiple sections in comments from the source of the given class.
102
 
     * @since 4.0
103
 
     */
104
 
        public StringBuffer[] getContentsForTest(int sections) throws IOException {
105
 
                return TestSourceReader.getContentsForTest(CTestPlugin.getDefault().getBundle(), "ui", getClass(), getName(), sections);
106
 
        }
107
 
        
108
 
    protected IFile createFile(IContainer container, String fileName, String contents) throws Exception {
109
 
        return TestSourceReader.createFile(container, new Path(fileName), contents);
110
 
    }
111
 
    
112
 
    protected IASTTranslationUnit createIndexBasedAST(IIndex index, ICProject project, IFile file) throws CModelException, CoreException {
113
 
        return TestSourceReader.createIndexBasedAST(index, project, file);
114
 
    }
115
 
 
116
 
        protected void waitForIndexer(IIndex index, IFile file, int maxmillis) throws Exception {
117
 
                boolean firstTime= true;
118
 
                long endTime= System.currentTimeMillis() + maxmillis;
119
 
                while (firstTime || System.currentTimeMillis() < endTime) {
120
 
                        if (!firstTime) 
121
 
                                Thread.sleep(50);
122
 
                        firstTime= false;
123
 
                        
124
 
                        if (CCorePlugin.getIndexManager().isIndexerSetupPostponed(CoreModel.getDefault().create(file.getProject())))
125
 
                                continue;
126
 
                        index.acquireReadLock();
127
 
                        try {
128
 
                                IIndexFile pfile= index.getFile(ILinkage.CPP_LINKAGE_ID, IndexLocationFactory.getWorkspaceIFL(file));
129
 
                                if (pfile != null && pfile.getTimestamp() >= file.getLocalTimeStamp()) {
130
 
                                        return;
131
 
                                }
132
 
                                pfile= index.getFile(ILinkage.C_LINKAGE_ID, IndexLocationFactory.getWorkspaceIFL(file));
133
 
                                if (pfile != null && pfile.getTimestamp() >= file.getLocalTimeStamp()) {
134
 
                                        return;
135
 
                                }
136
 
                        }
137
 
                        finally {
138
 
                                index.releaseReadLock();
139
 
                                int time= (int) (endTime- System.currentTimeMillis());
140
 
                                if (time > 0) {
141
 
                                        CCorePlugin.getIndexManager().joinIndexer(time, NPM);
142
 
                                }
143
 
                        }
144
 
                }
145
 
                throw new Exception("Indexer did not complete in time!");
146
 
        }
147
 
        
148
 
        protected void runEventQueue(int time) {
149
 
                final long endTime= System.currentTimeMillis()+time;
150
 
                while(true) {
151
 
                        while (Display.getCurrent().readAndDispatch());
152
 
                        long diff= endTime-System.currentTimeMillis();
153
 
                        if (diff <= 0) {
154
 
                                break;
155
 
                        }
156
 
                        try {
157
 
                                Thread.sleep(Math.min(20, diff));
158
 
                        } catch (InterruptedException e) {
159
 
                                return;
160
 
                        }
161
 
                }
162
 
        }
163
 
 
164
 
        protected void expandTreeItem(Tree tree, int idx) {
165
 
                expandTreeItem(tree, new int[] {idx});
166
 
        }
167
 
 
168
 
        protected void expandTreeItem(Tree tree, int idx1, int idx2) {
169
 
                expandTreeItem(tree, new int[] {idx1, idx2});
170
 
        }
171
 
 
172
 
        protected void expandTreeItem(Tree tree, int[] idxs) {
173
 
                TreeItem item= tree.getItem(idxs[0]);
174
 
                assertNotNull(item);
175
 
                expandTreeItem(item);
176
 
                for (int i=1; i < idxs.length; i++) {
177
 
                        item= item.getItem(idxs[i]);
178
 
                        assertNotNull(item);
179
 
                        expandTreeItem(item);
180
 
                }
181
 
        }
182
 
        
183
 
        protected void expandTreeItem(TreeItem item) {
184
 
                Event event = new Event();
185
 
                event.item = item;
186
 
                item.getParent().notifyListeners(SWT.Expand, event);    
187
 
                item.setExpanded(true);
188
 
                runEventQueue(0);
189
 
        }
190
 
 
191
 
        protected void selectTreeItem(Tree tree, int idx) {
192
 
                selectTreeItem(tree, new int[] {idx});
193
 
        }
194
 
 
195
 
        protected void selectTreeItem(Tree tree, int idx1, int idx2) {
196
 
                selectTreeItem(tree, new int[] {idx1, idx2});
197
 
        }
198
 
 
199
 
        protected void selectTreeItem(Tree tree, int[] idxs) {
200
 
                TreeItem item= tree.getItem(idxs[0]);
201
 
                assertNotNull(item);
202
 
                for (int i=1; i < idxs.length; i++) {
203
 
                        item= item.getItem(idxs[i]);
204
 
                        assertNotNull(item);
205
 
                }
206
 
                tree.setSelection(item);
207
 
                Event event = new Event();
208
 
                event.item = item;
209
 
                item.getParent().notifyListeners(SWT.Selection, event); 
210
 
                runEventQueue(0);
211
 
        }
212
 
 
213
 
        protected void closeEditor(IEditorPart editor) {
214
 
                IWorkbenchPartSite site;
215
 
                IWorkbenchPage page;
216
 
                if (editor != null && (site= editor.getSite()) != null && (page= site.getPage()) != null) {
217
 
                        page.closeEditor(editor, false);
218
 
                }
219
 
        }
220
 
        
221
 
        protected void closeAllEditors() {
222
 
                IWorkbenchWindow[] windows= PlatformUI.getWorkbench().getWorkbenchWindows();
223
 
                for (int i= 0; i < windows.length; i++) {
224
 
                        IWorkbenchPage[] pages= windows[i].getPages();
225
 
                        for (int j= 0; j < pages.length; j++) {
226
 
                                IWorkbenchPage page= pages[j];
227
 
                                page.closeAllEditors(false);
228
 
                        }
229
 
                }
230
 
        }
231
 
        
232
 
        protected void restoreAllParts() throws WorkbenchException {
233
 
                IWorkbenchPage page= PlatformUI.getWorkbench().getActiveWorkbenchWindow().getActivePage();
234
 
                page.zoomOut();
235
 
                runEventQueue(0);
236
 
 
237
 
                IViewReference[] viewRefs= page.getViewReferences();
238
 
                for (int i = 0; i < viewRefs.length; i++) {
239
 
                        IViewReference ref = viewRefs[i];
240
 
                        page.setPartState(ref, IWorkbenchPage.STATE_RESTORED);
241
 
                }
242
 
                IEditorReference[] editorRefs= page.getEditorReferences();
243
 
                for (int i = 0; i < editorRefs.length; i++) {
244
 
                        IEditorReference ref = editorRefs[i];
245
 
                        page.setPartState(ref, IWorkbenchPage.STATE_RESTORED);
246
 
                }
247
 
                runEventQueue(0);
248
 
        }
249
 
        
250
 
        protected IViewPart activateView(String id) throws PartInitException {
251
 
                IViewPart view= PlatformUI.getWorkbench().getActiveWorkbenchWindow().getActivePage().showView(id);
252
 
                assertNotNull(view);
253
 
                runEventQueue(0);
254
 
                return  view;
255
 
        }
256
 
        
257
 
        protected void executeCommand(IViewPart viewPart, String commandID) throws ExecutionException, NotDefinedException, NotEnabledException, NotHandledException {
258
 
                IHandlerService hs= (IHandlerService)viewPart.getSite().getService(IHandlerService.class);
259
 
                assertNotNull(hs);
260
 
                hs.executeCommand(commandID, null);
261
 
        }
262
 
 
263
 
        private Control[] findControls(Control w, Class<?> clazz) {
264
 
                ArrayList<Control> result= new ArrayList<Control>();
265
 
                findControls(w, clazz, result);
266
 
                return result.toArray(new Control[result.size()]);
267
 
        }
268
 
        
269
 
        private void findControls(Control w, Class<?> clazz, List<Control> result) {    
270
 
                if (clazz.isInstance(w)) {
271
 
                        result.add(w);
272
 
                }
273
 
                if (w instanceof Composite) {
274
 
                        Composite comp= (Composite) w;
275
 
                        Control[] children= comp.getChildren();
276
 
                        for (int i = 0; i < children.length; i++) {
277
 
                                findControls(children[i], clazz, result);
278
 
                        }
279
 
                }
280
 
        }
281
 
 
282
 
        final protected TreeItem checkTreeNode(IViewPart part, int i0, String label) {
283
 
                Tree tree= null;
284
 
                TreeItem root= null;
285
 
                StringBuilder cands= new StringBuilder();
286
 
                for (int i=0; i<400; i++) {
287
 
                        cands.setLength(0);
288
 
                        Control[] trees= findControls(part.getSite().getShell(), Tree.class);
289
 
                        for (int j = 0; j < trees.length; j++) {
290
 
                                try {
291
 
                                        tree= (Tree) trees[j];
292
 
                                        root= tree.getItem(i0);
293
 
                                        if (label.equals(root.getText())) {
294
 
                                                return root;
295
 
                                        }
296
 
                                        if (j > 0) {
297
 
                                                cands.append('|');
298
 
                                        }
299
 
                                        cands.append(root.getText());
300
 
                                } 
301
 
                                catch (SWTException e) {
302
 
                                        // in case widget was disposed, item may be replaced
303
 
                                }
304
 
                                catch (IllegalArgumentException e) {
305
 
                                        // item does not yet exist.
306
 
                                }
307
 
                        }
308
 
                        runEventQueue(10);
309
 
                }
310
 
                assertNotNull("No tree in viewpart", tree);
311
 
                assertNotNull("Tree node " + label + "{" + i0 + "} does not exist!", root);
312
 
                assertEquals(label, cands.toString());
313
 
                return root;
314
 
        }
315
 
 
316
 
        final protected TreeItem checkTreeNode(Tree tree, int i0, String label) {
317
 
                TreeItem root= null;
318
 
                for (int millis=0; millis < 5000; millis= millis==0 ? 1 : millis*2) {
319
 
                        runEventQueue(millis);
320
 
                        try {
321
 
                                root= tree.getItem(i0);
322
 
                                if (label.equals(root.getText())) {
323
 
                                        return root;
324
 
                                }
325
 
                        } 
326
 
                        catch (SWTException e) {
327
 
                                // in case widget was disposed, item may be replaced
328
 
                        }
329
 
                        catch (IllegalArgumentException e) {
330
 
                                // item does not yet exist.
331
 
                        }
332
 
                }
333
 
                assertNotNull("Tree node " + label + "{" + i0 + "} does not exist!", root);
334
 
                assertEquals(label, root.getText());
335
 
                return root;
336
 
        }
337
 
        
338
 
        final protected TreeItem checkTreeNode(Tree tree, int i0, int i1, String label) {
339
 
                TreeItem item= null;
340
 
                String itemText= null;
341
 
                for (int millis=0; millis < 5000; millis= millis==0 ? 1 : millis*2) {
342
 
                        runEventQueue(millis);
343
 
                        TreeItem root= tree.getItem(i0);
344
 
                        try {
345
 
                                TreeItem firstItem= root.getItem(0);
346
 
                                final String text= firstItem.getText();
347
 
                                if (text.length() > 0 && !text.equals("...")) {
348
 
                                        item= root.getItem(i1);
349
 
                                        itemText= item.getText();
350
 
                                        assertNotNull("Unexpected tree node " + itemText, label);
351
 
                                        if (label.equals(itemText)) {
352
 
                                                return item;
353
 
                                        }
354
 
                                        if (millis > 2000) {
355
 
                                                assertEquals(label, itemText);
356
 
                                                return item;
357
 
                                        }
358
 
                                }
359
 
                        } catch (IllegalArgumentException e) {
360
 
                                if (label != null) {
361
 
                                        fail("Tree node " + label + "{" + i0 + "," + i1 + "} does not exist!");
362
 
                                }
363
 
                                return null;
364
 
                        } catch (SWTException e) {
365
 
                                // widget was disposed, try again.
366
 
                        }
367
 
                }
368
 
                assertEquals("Timeout expired waiting for tree node {" + i0 + "," + i1 + "}", label, itemText);
369
 
                return null;
370
 
        }
371
 
        
372
 
        public static void assertEqualString(String actual, String expected) {
373
 
                StringAsserts.assertEqualString(actual, expected);
374
 
        }
375
 
}