1
2
3
4
5
6
7
8
9
10
11
12
13
14
15
16
17
18
19
20
21
22
23
24
25
26
27
28
29
30
31
32
33
34
35
36
37
38
39
40
41
42
43
44
45
46
47
48
49
50
51
52
53
54
55
56
57
58
59
60
61
62
63
64
65
66
67
68
69
70
71
72
73
74
75
76
77
78
79
80
81
82
83
84
85
86
87
88
89
90
91
92
93
94
95
96
97
98
99
100
101
102
103
104
105
106
107
108
109
110
111
112
113
114
115
116
117
118
119
120
121
122
123
124
125
126
127
128
129
130
131
132
133
134
135
136
137
138
139
140
141
142
143
144
145
146
147
148
149
150
151
152
153
154
155
156
157
158
159
160
161
162
163
164
165
166
167
168
169
170
171
172
173
174
175
176
177
178
179
180
181
182
183
184
185
186
187
188
189
190
191
192
193
194
195
196
197
198
199
200
201
202
203
204
205
206
207
208
209
210
211
212
213
214
215
216
217
218
219
|
/*******************************************************************************
* Copyright (c) 2009, 2013 Mountainminds GmbH & Co. KG and Contributors
* 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:
* Marc R. Hoffmann - initial API and implementation
*
*******************************************************************************/
package org.jacoco.core.analysis;
import java.io.File;
import java.io.FileInputStream;
import java.io.IOException;
import java.io.InputStream;
import java.util.StringTokenizer;
import java.util.zip.ZipEntry;
import java.util.zip.ZipInputStream;
import org.jacoco.core.data.ExecutionData;
import org.jacoco.core.data.ExecutionDataStore;
import org.jacoco.core.internal.ContentTypeDetector;
import org.jacoco.core.internal.analysis.ClassAnalyzer;
import org.jacoco.core.internal.analysis.StringPool;
import org.jacoco.core.internal.data.CRC64;
import org.jacoco.core.internal.flow.ClassProbesAdapter;
import org.objectweb.asm.ClassReader;
import org.objectweb.asm.ClassVisitor;
/**
* An {@link Analyzer} instance processes a set of Java class files and
* calculates coverage data for them. For each class file the result is reported
* to a given {@link ICoverageVisitor} instance. In addition the
* {@link Analyzer} requires a {@link ExecutionDataStore} instance that holds
* the execution data for the classes to analyze. The {@link Analyzer} offers
* several methods to analyze classes from a variety of sources.
*/
public class Analyzer {
private final ExecutionDataStore executionData;
private final ICoverageVisitor coverageVisitor;
private final StringPool stringPool;
/**
* Creates a new analyzer reporting to the given output.
*
* @param executionData
* execution data
* @param coverageVisitor
* the output instance that will coverage data for every analyzed
* class
*/
public Analyzer(final ExecutionDataStore executionData,
final ICoverageVisitor coverageVisitor) {
this.executionData = executionData;
this.coverageVisitor = coverageVisitor;
this.stringPool = new StringPool();
}
/**
* Creates an ASM class visitor for analysis.
*
* @param classid
* id of the class calculated with {@link CRC64}
* @return ASM visitor to write class definition to
*/
private ClassVisitor createAnalyzingVisitor(final long classid) {
final ExecutionData data = executionData.get(classid);
final boolean[] probes = data == null ? null : data.getProbes();
final ClassAnalyzer analyzer = new ClassAnalyzer(classid, probes,
stringPool) {
@Override
public void visitEnd() {
super.visitEnd();
coverageVisitor.visitCoverage(getCoverage());
}
};
return new ClassProbesAdapter(analyzer);
}
/**
* Analyzes the class given as a ASM reader.
*
* @param reader
* reader with class definitions
*/
public void analyzeClass(final ClassReader reader) {
final ClassVisitor visitor = createAnalyzingVisitor(CRC64
.checksum(reader.b));
reader.accept(visitor, 0);
}
/**
* Analyzes the class definition from a given in-memory buffer.
*
* @param buffer
* class definitions
*/
public void analyzeClass(final byte[] buffer) {
analyzeClass(new ClassReader(buffer));
}
/**
* Analyzes the class definition from a given input stream.
*
* @param input
* stream to read class definition from
* @throws IOException
* if the stream can't be read
*/
public void analyzeClass(final InputStream input) throws IOException {
analyzeClass(new ClassReader(input));
}
/**
* Analyzes all classes contained in the ZIP archive (jar, war, ear, etc.)
* given as an input stream. Contained archives are read recursively.
*
* @param input
* ZIP archive data
* @return number of class files found
* @throws IOException
* if the stream can't be read
*/
public int analyzeArchive(final InputStream input) throws IOException {
final ZipInputStream zip = new ZipInputStream(input);
int count = 0;
while (true) {
final ZipEntry entry = zip.getNextEntry();
if (entry == null) {
break;
}
count += analyzeAll(zip);
}
return count;
}
/**
* Analyzes all classes found in the given input stream. The input stream
* may either represent a single class file or a ZIP archive that is
* searched recursively for class files. All other content types are
* ignored.
*
* @param input
* input data
* @return number of class files found
* @throws IOException
* if the stream can't be read
*/
public int analyzeAll(final InputStream input) throws IOException {
final ContentTypeDetector detector = new ContentTypeDetector(input);
switch (detector.getType()) {
case ContentTypeDetector.CLASSFILE:
analyzeClass(detector.getInputStream());
return 1;
case ContentTypeDetector.ZIPFILE:
return analyzeArchive(detector.getInputStream());
default:
return 0;
}
}
/**
* Analyzes all class files contained in the given file or folder. Class
* files as well as ZIP files are considered. Folders are searched
* recursively.
*
* @param file
* file or folder to look for class files
* @return number of class files found
* @throws IOException
* if the file can't be read
*/
public int analyzeAll(final File file) throws IOException {
int count = 0;
if (file.isDirectory()) {
for (final File f : file.listFiles()) {
count += analyzeAll(f);
}
} else {
final InputStream in = new FileInputStream(file);
try {
count += analyzeAll(in);
} finally {
in.close();
}
}
return count;
}
/**
* Analyzes all classes from the given class path. Directories containing
* class files as well as archive files are considered.
*
* @param path
* path definition
* @param basedir
* optional base directory, if <code>null</code> the current
* working directory is used as the base for relative path
* entries
* @return number of class files found
* @throws IOException
* if a file can't be read
*/
public int analyzeAll(final String path, final File basedir)
throws IOException {
int count = 0;
final StringTokenizer st = new StringTokenizer(path, File.pathSeparator);
while (st.hasMoreTokens()) {
count += analyzeAll(new File(basedir, st.nextToken()));
}
return count;
}
}
|
