Java > Open Source Codes > de > uka > ipd > coverage > plugin > ui > CoverageViewPart


1 package de.uka.ipd.coverage.plugin.ui;
2
3
4 import java.net.MalformedURLException ;
5 import java.net.URL ;
6 import java.util.*;
7
8 import org.apache.bcel.classfile.JavaClass;
9 import org.eclipse.core.resources.*;
10 import org.eclipse.core.runtime.CoreException;
11 import org.eclipse.core.runtime.IProgressMonitor;
12 import org.eclipse.jdt.core.*;
13 import org.eclipse.jdt.ui.JavaUI;
14 import org.eclipse.jface.action.*;
15 import org.eclipse.jface.dialogs.MessageDialog;
16 import org.eclipse.jface.resource.ImageDescriptor;
17 import org.eclipse.jface.viewers.*;
18 import org.eclipse.swt.graphics.Image;
19 import org.eclipse.swt.widgets.Composite;
20 import org.eclipse.swt.widgets.Display;
21 import org.eclipse.swt.widgets.Menu;
22 import org.eclipse.ui.*;
23 import org.eclipse.ui.part.ViewPart;
24
25 import de.uka.ipd.coverage.CoverageSystemPartsProvider;
26 import de.uka.ipd.coverage.junit.CoverageTestResult;
27 import de.uka.ipd.coverage.natures.*;
28 import de.uka.ipd.coverage.natures.all_uses.AllUsesCompleteCoverage;
29 import de.uka.ipd.coverage.natures.all_uses.Definition;
30 import de.uka.ipd.coverage.natures.all_uses.UsesCoverage;
31 import de.uka.ipd.coverage.plugin.CoveragePlugin;
32 import de.uka.ipd.coverage.plugin.launcher.TestStatusListener;
33 import de.uka.ipd.coverage.recording.CoverageState;
34 import de.uka.ipd.coverage.recording.RegisteredMethod;
35 import de.uka.ipd.coverage.utils.Logger;
36
37
38 /**
39  * This sample class demonstrates how to plug-in a new
40  * workbench view. The view shows data obtained from the
41  * model. The sample creates a dummy model on the fly,
42  * but a real implementation would connect to the model
43  * available either in this or another plug-in (e.g. the workspace).
44  * The view is connected to the model using a content provider.
45  * <p>
46  * The view uses a label provider to define how model
47  * objects should be presented in the view. Each
48  * view can present the same model objects using
49  * different labels and icons, if needed. Alternatively,
50  * a single label provider can be shared between views
51  * in order to ensure that objects of the same type are
52  * presented in the same way everywhere.
53  * <p>
54  */
55
56 public class CoverageViewPart extends ViewPart implements TestStatusListener {
57     private TreeViewer viewer;
58     private Action doubleClickAction;
59
60     private Logger logger = new Logger(this);
61     private ViewContentProvider viewContentProvider;
62     private Action[] actions;
63     
64
65     public static Image createImage(String path) {
66         try {
67             URL url = new URL ("file://home/arwate/workspace/org.eclipse.jdt.junit/icons/full/eview16/juniterr.gif");
68             ImageDescriptor id= ImageDescriptor.createFromURL(url);
69             return id.createImage();
70         } catch (MalformedURLException e) {
71             // fall through
72 }
73         return null;
74     }
75
76     
77     
78  
79     class ViewContentProvider implements ITreeContentProvider {
80
81         private Logger logger = new Logger(this);
82         private TestedClass[] classes = new TestedClass[0];
83         
84         // serves as cache for already computed values.
85 // maps String (packageName) to TestedClass[]
86 // and String "root" to String[] (packageNames)
87 private Map valueCache = new HashMap();
88         
89         public void inputChanged(Viewer v, Object oldInput, Object newInput) {
90             logger.info("Viewer v: " + v + "\noldInput: " + //$NON-NLS-1$ //$NON-NLS-2$
91 oldInput + "\nnewInput: " + newInput); //$NON-NLS-1$
92 logger.warning("implement me: inputChanged()"); //$NON-NLS-1$
93 }
94         
95         public void dispose() {
96             logger.warning("implement me: dispose()"); //$NON-NLS-1$
97 }
98         
99         public Object [] getChildren(Object parentElement) {
100             logger.debug("entering getChildren(" + parentElement + ")"); //$NON-NLS-1$ //$NON-NLS-2$
101 Object [] result = null;
102             if (parentElement instanceof String ) {
103                 result = extractChildrenOfPackageName((String ) parentElement);
104             }
105             logger.debug("returning " + result + " as children"); //$NON-NLS-1$ //$NON-NLS-2$
106 return result;
107         }
108         
109         public Object getParent(Object element) {
110             logger.debug("entering getParent(" + element + ")"); //$NON-NLS-1$ //$NON-NLS-2$
111 Object result = null;
112             if (element instanceof RegisteredMethod) {
113                 RegisteredMethod rm = (RegisteredMethod) element;
114                 result = rm.getJavaClass();
115             } else if (element instanceof JavaClass) {
116                 JavaClass jc = (JavaClass) element;
117                 result = jc.getPackageName();
118             }
119             logger.debug("returning " + result + " as parent"); //$NON-NLS-1$ //$NON-NLS-2$
120 return result;
121         }
122         
123         public boolean hasChildren(Object element) {
124             logger.debug("entering hasChildren(" + element + ")"); //$NON-NLS-1$ //$NON-NLS-2$
125 if (element instanceof TestedClass) {
126                 logger.debug( element + " has no children"); //$NON-NLS-1$
127 return false;
128             }
129             logger.debug( element + " has children"); //$NON-NLS-1$
130 return true;
131         }
132         
133         public Object [] getElements(Object inputElement) {
134             logger.debug("entering getElements("+inputElement+")"); //$NON-NLS-1$ //$NON-NLS-2$
135 if (valueCache.containsKey("root")) { //$NON-NLS-1$
136 logger.debug("getElements: returning cached result"); //$NON-NLS-1$
137 return (String []) valueCache.get("root"); //$NON-NLS-1$
138 }
139             List pnList = new ArrayList();
140             for (int i = 0; i < classes.length; i++) {
141                 String currentPackageName = classes[i].getTestedClass().getPackageName();
142                 if (!pnList.contains(currentPackageName)) {
143                     pnList.add(currentPackageName);
144                 }
145             }
146             String [] result = (String []) pnList.toArray(new String [pnList.size()]);
147             valueCache.put("root", result); //$NON-NLS-1$
148 logger.debug("getElements: returning calculated result"); //$NON-NLS-1$
149 return result;
150         }
151         
152         private void setContent(TestedClass[] classes) {
153             this.classes = classes;
154             valueCache.clear();
155             runInDisplayThread(new Runnable () {
156                 public void run() {
157                     viewer.refresh();
158                 }
159             });
160         }
161         
162 // /**
163 // * @return returns an array of RegisteredMethods being those
164 // * RegisteredMethods that are methods of the given class
165 // */
166 // private Object[] extractChildrenOfJavaClass(TestedClass jClass) {
167 // logger.debug("entering extractChildrenOfJavaClass("+jClass+")");
168 // if (valueCache.containsKey(jClass)) {
169 // logger.debug("extractChildrenOfJavaClass: returning cached children");
170 // return (RegisteredMethod[]) valueCache.get(jClass);
171 // }
172 // List rmList = new ArrayList(20);
173 // for (int i = 0; i < classes.length; i++) {
174 // CompleteCoverage coverage = CoverageNatureFactory.getNature().
175 // getCompleteCoverage(jClass.getTestedClass());
176 // if (jClass.equals(rms[i].getJavaClass())) {
177 // rmList.add(rms[i]);
178 // }
179 // }
180 // RegisteredMethod[] result =
181 // (RegisteredMethod[]) rmList.toArray(new RegisteredMethod[rmList.size()]);
182 // valueCache.put(jClass, result);
183 // logger.debug("extractChildrenOfJavaClass: returning calculated children");
184 // return result;
185 // }
186
187         /**
188          * @return returns an array of TestedClass, being those classes
189          * that are in the given package
190          */
191         private Object [] extractChildrenOfPackageName(String packageName) {
192             logger.debug("entering extractChildrenOfPackageName("+packageName+")"); //$NON-NLS-1$ //$NON-NLS-2$
193 if (valueCache.containsKey(packageName)) {
194                 logger.debug("extractChildrenOfPackageName: returning cached children"); //$NON-NLS-1$
195 return (JavaClass[]) valueCache.get(packageName);
196             }
197             List tcList = new ArrayList(20);
198             for (int i = 0; i < classes.length; i++) {
199                 if (packageName.equals(classes[i].getTestedClass().getPackageName())
200                         && (!tcList.contains(classes[i]))) {
201                     tcList.add(classes[i]);
202                 }
203             }
204             TestedClass[] result = (TestedClass[]) tcList.toArray(new TestedClass[tcList.size()]);
205             valueCache.put(packageName, result);
206             logger.debug("extractChildrenOfPackageName: returning calculated children"); //$NON-NLS-1$
207 return result;
208         }
209
210 }
211     
212     class ViewLabelProvider extends LabelProvider {
213         
214         
215         private ViewLabelProvider() {
216             String iconPath = "icons/"; //$NON-NLS-1$
217 String [] icons = new String [] {
218                 "package_", //$NON-NLS-1$
219 "type_full", //$NON-NLS-1$
220 "type_partial", //$NON-NLS-1$
221 "type_none", //$NON-NLS-1$
222 };
223             CoveragePlugin.getDefault().getImageDescriptors(icons, iconPath);
224         }
225         
226         public Image getImage(Object obj) {
227             CoveragePlugin cplugin = CoveragePlugin.getDefault();
228             if (obj instanceof String ) {
229                 String packName = (String ) obj;
230                 // XXX: Coverage fuers Paket rauskriegen
231 return cplugin.getImage("package_"); //$NON-NLS-1$
232 } else if (obj instanceof TestedClass) {
233                 TestedClass tc = (TestedClass) obj;
234                 if (tc.getState() == CoverageState.FULL_COVERAGE) {
235                     return cplugin.getImage("type_full"); //$NON-NLS-1$
236 } else if (tc.getState() == CoverageState.PARTIAL_COVERAGE) {
237                     return cplugin.getImage("type_partial"); //$NON-NLS-1$
238 } else if (tc.getState() == CoverageState.NO_COVERAGE) {
239                     return cplugin.getImage("type_none"); //$NON-NLS-1$
240 }
241             }
242             throw new AssertionError ("element type not in tree!"); //$NON-NLS-1$
243 }
244         
245         public String getText(Object element) {
246             if (element instanceof String ) {
247                 return element.toString();
248             } else if (element instanceof TestedClass) {
249                 String className = ((TestedClass) element).getTestedClass().getClassName();
250                 int index = className.lastIndexOf("."); //$NON-NLS-1$
251 return className.substring(index + 1);
252             }
253             throw new AssertionError ("element type not in tree!"); //$NON-NLS-1$
254 }
255     }
256
257     /**
258      * The constructor.
259      */
260     public CoverageViewPart() {
261         CoverageSystemPartsProvider.getInstance().setViewPart(this);
262     }
263
264     /**
265      * This is a callback that will allow us
266      * to create the viewer and initialize it.
267      */
268     public void createPartControl(Composite parent) {
269 // viewer = new TableViewer(parent, SWT.MULTI | SWT.H_SCROLL | SWT.V_SCROLL);
270 // viewer.setContentProvider(new ViewContentProvider());
271 // viewer.setLabelProvider(new ViewLabelProvider());
272 // viewer.setInput(getViewSite());
273 viewer = new TreeViewer(parent);
274         viewContentProvider = new ViewContentProvider();
275         viewer.setContentProvider(viewContentProvider);
276         viewer.setLabelProvider(new ViewLabelProvider());
277         viewer.setInput(getViewSite());
278         makeActions();
279         hookContextMenu();
280         hookDoubleClickAction();
281         contributeToActionBars();
282     }
283             
284     private void hookContextMenu() {
285         MenuManager menuMgr = new MenuManager("#PopupMenu"); //$NON-NLS-1$
286 menuMgr.setRemoveAllWhenShown(true);
287         menuMgr.addMenuListener(new IMenuListener() {
288             public void menuAboutToShow(IMenuManager manager) {
289                 CoverageViewPart.this.fillContextMenu(manager);
290             }
291         });
292         Menu menu = menuMgr.createContextMenu(viewer.getControl());
293         viewer.getControl().setMenu(menu);
294         getSite().registerContextMenu(menuMgr, viewer);
295     }
296
297     private void contributeToActionBars() {
298         IActionBars bars = getViewSite().getActionBars();
299         fillLocalPullDown(bars.getMenuManager());
300         fillLocalToolBar(bars.getToolBarManager());
301     }
302
303     private void fillLocalPullDown(IMenuManager manager) {
304 // Action action1 = new Action() {};
305 // action1.setText("Action in LocalPullDown");
306 // manager.add(action1);
307
308     }
309
310     private void fillContextMenu(IMenuManager manager) {
311         for (int i = 0; i < actions.length; i++) {
312             manager.add(actions[i]);
313         }
314     }
315     
316     private void fillLocalToolBar(IToolBarManager manager) {
317         for (int i = 0; i < actions.length; i++) {
318             manager.add(actions[i]);
319         }
320     }
321     
322     /**
323      * this is an Action that selects a CoverageNature. On running
324      * the nature is selected and the data model and view is updated.
325      * Created on Apr 10, 2005
326      * @author Matthias Kempka
327      */
328     private class DescriptorSelectionAction extends Action {
329         private CoverageNatureDescriptor descriptor;
330         public DescriptorSelectionAction(CoverageNatureDescriptor descriptor) {
331             this.descriptor = descriptor;
332             setText(descriptor.getName());
333             setToolTipText(descriptor.getDescription());
334             setImageDescriptor(descriptor.getImageDescriptor());
335         }
336         public void run() {
337             clear();
338             CoverageNatureFactory.getInstance().setCoverageNature(descriptor.getID());
339             notifyDataReceived();
340         }
341     }
342
343     private void makeActions() {
344
345         CoverageNatureDescriptor[] descs = CoverageNatureFactory.getInstance().
346                                                 getAvailableNatures();
347         
348         actions = new Action[descs.length + 1];
349         for (int i = 0; i < descs.length; i++) {
350             actions[i] = new DescriptorSelectionAction(descs[i]);
351         }
352         
353         actions[descs.length] = new Action() {
354             public void run() {
355                 CoverageTestResult.setRegisteredMethods(new RegisteredMethod[0]);
356                 clear();
357             }
358         };
359         
360         actions[descs.length].setText(Messages.getString("CoverageViewPart.0")); //$NON-NLS-1$
361
362         doubleClickAction = new Action() {
363             public void run() {
364                 ISelection selection = viewer.getSelection();
365                 Object obj = ((IStructuredSelection)selection).getFirstElement();
366                 if (obj instanceof TestedClass) {
367                     openAndRevealTestedClass(obj);
368                 }
369             }
370
371         };
372     }
373
374     private void hookDoubleClickAction() {
375         viewer.addDoubleClickListener(new IDoubleClickListener() {
376             public void doubleClick(DoubleClickEvent event) {
377                 doubleClickAction.run();
378             }
379         });
380     }
381     private void showMessage(String message) {
382         MessageDialog.openInformation(
383             viewer.getControl().getShell(),
384             Messages.getString("CoverageViewPart.43"), //$NON-NLS-1$
385 message);
386     }
387
388     public Display getDisplay() {
389         return this.viewer.getControl().getDisplay();
390     }
391
392     /**
393      * Passing the focus request to the viewer's control.
394      */
395     public void setFocus() {
396         viewer.getControl().setFocus();
397     }
398
399     /**
400      * @param obj
401      */
402     private void openAndRevealTestedClass(Object obj) {
403         TestedClass tc = (TestedClass) obj;
404         try {
405             IType member = tc.getType();
406             final ICompilationUnit cu = member.getCompilationUnit();
407             IEditorPart javaEditor = JavaUI.openInEditor(cu);
408             JavaUI.revealInEditor(javaEditor, (IJavaElement) member);
409             evaluateTestedClass(tc);
410         } catch (JavaModelException e) {
411             showMessage(Messages.getString("CoverageViewPart.44")+obj.toString()); //$NON-NLS-1$
412 logger.log(e);
413         } catch (PartInitException e) {
414             showMessage(Messages.getString("CoverageViewPart.45")+obj.toString()); //$NON-NLS-1$
415 logger.log(e);
416         }
417     }
418     
419     private void createMarkers(TestedClass[] tcs) {
420         try {
421             // the comparison between open files and class names is done
422 // using the file name without directory information.
423 // This may result in evaluating classes that are not actually
424 // open, but is good enough since the target is to reduce from
425 // evaluating *all* classes to *some* classes.
426 String [] openFiles = getOpenFileNames();
427             for (int i = 0; i < tcs.length; i++) {
428                 if (isTestedClassInOpenFiles(openFiles, tcs[i])) {
429                     evaluateTestedClass(tcs[i]);
430                 }
431             }
432             CoveragePlugin.getDefault().getMarkerManager().notifyListeners();
433         } catch (CoreException e) {
434             e.printStackTrace();
435             logger.log(e);
436         }
437     }
438     
439     /**
440      * @param tc
441      * @param i
442      * @throws JavaModelException
443      */
444     private void evaluateTestedClass(TestedClass tc) throws JavaModelException {
445         CompleteCoverage cc = CoverageNatureFactory.getNature().getCompleteCoverage(tc.getTestedClass());
446         final IResource resource = tc.getType().getCompilationUnit().getCorrespondingResource();
447         for (cc.resetIterator(); cc.hasNextLine();) {
448             ISourceCodeLine line = cc.getNextLine();
449             CoverageState state = cc.getCoverage(line);
450             String reason = cc.getReason(line);
451             UsesCoverage uses = null;
452             if (cc instanceof AllUsesCompleteCoverage) {
453                 AllUsesCompleteCoverage aucc =
454                     (AllUsesCompleteCoverage) cc;
455                 uses = aucc.getUsesCoverage(line);
456             }
457             createMarkerFor(resource, line, state, reason, uses);
458         }
459     }
460
461     private boolean isTestedClassInOpenFiles(String [] openFiles, TestedClass class1) {
462         String tcsname = class1.getTestedClass().getSourceFileName();
463         for (int i = 0; i < openFiles.length; i++) {
464             if (tcsname.equals(openFiles[i])) {
465                 return true;
466             }
467         }
468         return false;
469     }
470
471     /**
472      *
473      */
474     private String [] getOpenFileNames() {
475         List editorRefs = new ArrayList();
476         IWorkbenchWindow[] windows = CoveragePlugin.getDefault().getWorkbench().getWorkbenchWindows();
477         for (int i = 0; i < windows.length; i++) {
478             IWorkbenchPage page = windows[i].getActivePage();
479             if (page != null) {
480                 IEditorReference[] refs = page.getEditorReferences();
481                 editorRefs.addAll(Arrays.asList(refs));
482             }
483         }
484         String [] names = new String [editorRefs.size()];
485         int i = 0;
486         for (Iterator iter = editorRefs.iterator(); iter.hasNext();) {
487             IEditorReference ref = (IEditorReference) iter.next();
488             names[i++] = ref.getTitle();
489         }
490         return names;
491     }
492
493     /**
494      * @param resource
495      * @param line
496      * @param state
497      */
498     private void createMarkerFor(final IResource resource,
499             final ISourceCodeLine line,
500             final CoverageState state,
501             final String reason,
502             final UsesCoverage uses) {
503         final Map atts = new HashMap();
504         atts.put(IMarker.LINE_NUMBER, new Integer (line.getSourceCodeLine()));
505         if (line instanceof Definition) {
506             atts.put(CoverageMarkerManager.ATT_DEFINITION, line);
507         }
508         atts.put(IMarker.MESSAGE, reason);
509         atts.put(IMarker.TRANSIENT, new Boolean (true));
510         atts.put(CoverageMarkerManager.ATT_COVERAGE, state.toString());
511         putUsesToAttributes(uses, atts);
512
513         IWorkspaceRunnable r= new IWorkspaceRunnable() {
514             public void run(IProgressMonitor monitor) throws CoreException {
515                 IMarker marker= resource.createMarker(CoverageMarkerManager.TYPE_COVERAGEMARKER);
516                 marker.setAttributes(atts);
517                 CoveragePlugin.getDefault().getMarkerManager().addPrimaryMarker(marker, false);
518             }
519         };
520         
521         try {
522             resource.getWorkspace().run(r, null,IWorkspace.AVOID_UPDATE, null);
523         } catch (CoreException e) {
524             e.printStackTrace();
525             logger.log(e);
526         }
527     }
528
529     /**
530      * @param uses
531      * @param atts
532      */
533     private void putUsesToAttributes(final UsesCoverage uses, final Map atts) {
534         if (uses != null) {
535             String covered = "";
536             int[] lines = uses.getCoveredUsesSourceLineNumbers();
537             for (int i = 0; i < lines.length; i++) {
538                 covered = covered + " " + lines[i];
539             }
540             atts.put(CoverageMarkerManager.ATT_COVERED_USES, covered);
541             String uncovered = "";
542             lines = uses.getUncoveredUsesSourceLineNumbers();
543             for (int i = 0; i < lines.length; i++) {
544                 uncovered = uncovered + " " + lines[i];
545             }
546             atts.put(CoverageMarkerManager.ATT_UNCOVERED_USES, uncovered);
547         }
548     }
549
550     private void deleteMarkers() {
551         CoveragePlugin.getDefault().getMarkerManager().deletePrimaryMarkers();
552         CoveragePlugin.getDefault().getMarkerManager().deleteSecondaryMarkers();
553     }
554
555     
556     private void clear() {
557         deleteMarkers();
558         CoverageNatureFactory.getNature().clear();
559         viewContentProvider.setContent(new TestedClass[0]);
560     }
561     
562     public void notifyWaiting() {
563         clear();
564     }
565
566     public void notifyDataReceived() {
567         RegisteredMethod[] methods = CoverageTestResult.getRegisteredMethods();
568         CoverageNature nature = CoverageNatureFactory.getNature();
569         nature.clear();
570         for (int i = 0; i < methods.length; i++) {
571             methods[i].acceptVisitor(nature);
572         }
573         TestedClass[] classes = nature.getMeasuredClasses();
574         viewContentProvider.setContent(classes);
575         createMarkers(classes);
576         final CoverageMarkerView markerView = CoveragePlugin.getDefault().getMarkerView();
577         if (markerView != null) {
578             runInDisplayThread(new Runnable () {
579                 public void run() {
580                     //TODO: For some reason this doesn't work as intended.
581 markerView.getViewSite().getShell().forceActive();
582                 }
583             });
584         }
585     }
586     
587     public void dispose() {
588         deleteMarkers();
589         super.dispose();
590     }
591
592     /**
593      *
594      */
595     private void runInDisplayThread(Runnable runnable) {
596         Display display = getDisplay();
597         if(!display.isDisposed()) {
598             display.syncExec(runnable);
599         }
600     }
601 }

A to Z: JavaDoc & Examples

---

Daily Java News & Articles

---

Open Source Projects

---

Open Source Codes

---

Free Computer Books

---

Remove Frame

---

Popular Tags