KickJava   Java API By Example, From Geeks To Geeks.

Java > Open Source Codes > com > mountainminds > eclemma > internal > core > analysis > SessionAnalyzer


1 /*******************************************************************************
2  * Copyright (c) 2006 Mountainminds GmbH & Co. KG
3  * This software is provided under the terms of the Eclipse Public License v1.0
4  * See http://www.eclipse.org/legal/epl-v10.html.
5  *
6  * $Id: SessionAnalyzer.java 199 2006-12-18 14:49:40Z mtnminds $
7  ******************************************************************************/

8 package com.mountainminds.eclemma.internal.core.analysis;
9
10 import java.io.File JavaDoc;
11 import java.io.IOException JavaDoc;
12 import java.util.HashMap JavaDoc;
13 import java.util.Iterator JavaDoc;
14 import java.util.Map JavaDoc;
15
16 import org.eclipse.core.resources.IResource;
17 import org.eclipse.core.runtime.CoreException;
18 import org.eclipse.core.runtime.IPath;
19 import org.eclipse.core.runtime.IProgressMonitor;
20 import org.eclipse.core.runtime.SubProgressMonitor;
21 import org.eclipse.jdt.core.IJavaElement;
22 import org.eclipse.jdt.core.IPackageFragmentRoot;
23 import org.eclipse.jdt.core.IType;
24 import org.eclipse.osgi.util.NLS;
25
26 import com.mountainminds.eclemma.core.EclEmmaStatus;
27 import com.mountainminds.eclemma.core.ICoverageSession;
28 import com.mountainminds.eclemma.core.IInstrumentation;
29 import com.mountainminds.eclemma.core.analysis.IJavaModelCoverage;
30 import com.mountainminds.eclemma.internal.core.CoreMessages;
31 import com.mountainminds.eclemma.internal.core.DebugOptions;
32 import com.mountainminds.eclemma.internal.core.DebugOptions.ITracer;
33 import com.mountainminds.eclemma.internal.core.analysis.TypeCoverage.UnboundMethodCoverage;
34 import com.vladium.emma.data.ClassDescriptor;
35 import com.vladium.emma.data.DataFactory;
36 import com.vladium.emma.data.ICoverageData;
37 import com.vladium.emma.data.IMergeable;
38 import com.vladium.emma.data.IMetaData;
39 import com.vladium.emma.data.MethodDescriptor;
40 import com.vladium.emma.data.ICoverageData.DataHolder;
41
42 /**
43  * @author Marc R. Hoffmann
44  * @version $Revision: 199 $
45  */

46 public class SessionAnalyzer {
47
48   private static final ITracer TRACER = DebugOptions.ANALYSISTRACER;
49   private static final ITracer PERFORMANCE = DebugOptions.PERFORMANCETRACER;
50
51   private JavaModelCoverage modelcoverage;
52
53   public IJavaModelCoverage processSession(ICoverageSession session, IProgressMonitor monitor)
54       throws CoreException {
55     PERFORMANCE.startTimer();
56     PERFORMANCE.startMemoryUsage();
57     modelcoverage = new JavaModelCoverage();
58     IPath[] coveragefiles = session.getCoverageDataFiles();
59     IInstrumentation[] instrumentations = session.getInstrumentations();
60     monitor.beginTask(NLS.bind(CoreMessages.AnalyzingCoverageSession_task, session.getDescription()),
61         coveragefiles.length + instrumentations.length);
62     ICoverageData coveragedata = null;
63     for (int i = 0; i < coveragefiles.length && !monitor.isCanceled(); i++) {
64       coveragedata = processCoveragedataFile(coveragedata, coveragefiles[i]);
65       monitor.worked(1);
66     }
67     for (int i = 0; i < instrumentations.length && !monitor.isCanceled(); i++) {
68       processMetadataFile(coveragedata, instrumentations[i],
69           new SubProgressMonitor(monitor, 1));
70     }
71     monitor.done();
72     PERFORMANCE.stopTimer("loading " + session.getDescription()); //$NON-NLS-1$
73
PERFORMANCE.stopMemoryUsage("loading " + session.getDescription()); //$NON-NLS-1$
74
return modelcoverage;
75   }
76
77   private ICoverageData processCoveragedataFile(ICoverageData coveragedata,
78       IPath path) throws CoreException {
79     try {
80       File JavaDoc f = path.toFile();
81       if (f.exists()) {
82         IMergeable data = DataFactory.load(f)[DataFactory.TYPE_COVERAGEDATA];
83         if (coveragedata == null) {
84           coveragedata = (ICoverageData) data;
85         } else {
86           coveragedata = (ICoverageData) coveragedata.merge(data);
87         }
88       }
89       return coveragedata;
90     } catch (IOException JavaDoc e) {
91       throw new CoreException(EclEmmaStatus.COVERAGEDATA_FILE_READ_ERROR
92           .getStatus(path, e));
93     }
94   }
95
96   private void processMetadataFile(ICoverageData coveragedata, IInstrumentation instrumentation,
97       IProgressMonitor monitor) throws CoreException {
98     IPath metadatafile = instrumentation.getMetaDataFile();
99     File JavaDoc f = metadatafile.toFile();
100     if (f.exists()) {
101       IMetaData metadata;
102       try {
103         metadata = (IMetaData) DataFactory.load(f)[DataFactory.TYPE_METADATA];
104       } catch (IOException JavaDoc e) {
105         throw new CoreException(EclEmmaStatus.METADATA_FILE_READ_ERROR.getStatus(
106             metadatafile, e));
107       }
108       IPackageFragmentRoot[] roots = instrumentation.getClassFiles().getPackageFragmentRoots();
109       TypeTraverser jep = new TypeTraverser(roots);
110       jep.process(new TypeVisitor(metadata, coveragedata), monitor);
111     }
112   }
113   
114   private class TypeVisitor implements ITypeVisitor {
115     
116     private final ICoverageData coveragedata;
117     private final Map JavaDoc descriptors;
118     
119     TypeVisitor(IMetaData metadata, ICoverageData coveragedata) {
120       this.coveragedata = coveragedata;
121       this.descriptors = new HashMap JavaDoc();
122       for (Iterator JavaDoc i = metadata.iterator(); i.hasNext(); ) {
123         ClassDescriptor cd = (ClassDescriptor) i.next();
124         descriptors.put(cd.getClassVMName(), cd);
125       }
126     }
127
128     public void visit(IType type, String JavaDoc vmname) {
129       ClassDescriptor descriptor = (ClassDescriptor) descriptors.remove(vmname);
130       if (descriptor != null) {
131         DataHolder data = coveragedata == null ? null : coveragedata.getCoverage(descriptor);
132         if (data != null && data.m_stamp != descriptor.getStamp()) {
133           TRACER.trace("Invalid meta data signature for {0}.", descriptor.getClassVMName()); //$NON-NLS-1$
134
} else {
135           TypeCoverage typecoverage = (TypeCoverage) getCoverage(type, descriptor.hasCompleteLineNumberInfo());
136           IResource resource = type.getResource();
137           typecoverage.addType(data != null);
138           MethodDescriptor[] methods = descriptor.getMethods();
139           UnboundMethodCoverage[] ubcoverage = new UnboundMethodCoverage[methods.length];
140           boolean[][] covered = data == null ? null : data.m_coverage;
141           for (int i = 0; i < methods.length; i++) {
142             ubcoverage[i] = processMethodCoverage(methods[i], covered == null ? null : covered[i], typecoverage, resource);
143           }
144           typecoverage.setUnboundMethods(ubcoverage);
145         }
146       }
147     }
148
149     public void done() {
150       // dump what's left
151
for (Iterator JavaDoc i = descriptors.keySet().iterator(); i.hasNext(); ) {
152         TRACER.trace("Instrumented type {0} has not been processed.", i.next()); //$NON-NLS-1$
153
}
154     }
155     
156   }
157   
158   private boolean isMethodCovered(boolean[] blocks) {
159     for (int i = 0; blocks != null && i < blocks.length; i++) {
160       if (blocks[i]) return true;
161     }
162     return false;
163   }
164   
165   private UnboundMethodCoverage processMethodCoverage(MethodDescriptor descriptor, boolean[] covered, JavaElementCoverage parentcoverage, IResource resource) {
166     JavaElementCoverage coverage = new JavaElementCoverage(parentcoverage, descriptor.hasLineNumberInfo(), resource);
167     coverage.addMethod(isMethodCovered(covered));
168     int[] blocksizes = descriptor.getBlockSizes();
169     if (blocksizes != null) {
170       int blockcount = blocksizes.length;
171       int[][] blocklines = descriptor.getBlockMap();
172       for (int i = 0; i < blockcount; i++) {
173         coverage.addBlock(blocksizes[i], blocklines == null ? null : blocklines[i],
174             covered == null ? false : covered[i]);
175       }
176     }
177     return new UnboundMethodCoverage(descriptor.getName(), descriptor.getDescriptor(), coverage);
178   }
179
180   private JavaElementCoverage getCoverage(IJavaElement element, boolean haslines) {
181     if (element == null)
182       return null;
183     JavaElementCoverage c = (JavaElementCoverage) modelcoverage.getCoverageFor(element);
184     if (c == null) {
185       switch (element.getElementType()) {
186       case IJavaElement.JAVA_MODEL:
187         c = modelcoverage;
188         break;
189       case IJavaElement.JAVA_PROJECT:
190       case IJavaElement.PACKAGE_FRAGMENT_ROOT:
191       case IJavaElement.PACKAGE_FRAGMENT:
192         c = new JavaElementCoverage(getCoverage(element.getParent(), false), false, element.getResource());
193         break;
194       case IJavaElement.TYPE:
195         c = new TypeCoverage(getCoverage(element.getParent(), haslines), haslines, element.getResource());
196         break;
197       default:
198         c = new JavaElementCoverage(getCoverage(element.getParent(), haslines), haslines, element.getResource());
199         break;
200     }
201       modelcoverage.put(element, c);
202     }
203     return c;
204   }
205   
206 }
207
Popular Tags