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
|
/*******************************************************************************
* 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.instr;
import java.io.ByteArrayOutputStream;
import java.io.IOException;
import java.io.InputStream;
import java.io.OutputStream;
import java.util.zip.GZIPInputStream;
import java.util.zip.GZIPOutputStream;
import java.util.zip.ZipEntry;
import java.util.zip.ZipInputStream;
import java.util.zip.ZipOutputStream;
import org.jacoco.core.internal.ContentTypeDetector;
import org.jacoco.core.internal.Pack200Streams;
import org.jacoco.core.internal.data.CRC64;
import org.jacoco.core.internal.flow.ClassProbesAdapter;
import org.jacoco.core.internal.instr.ClassInstrumenter;
import org.jacoco.core.runtime.IExecutionDataAccessorGenerator;
import org.objectweb.asm.ClassReader;
import org.objectweb.asm.ClassVisitor;
import org.objectweb.asm.ClassWriter;
/**
* Several APIs to instrument Java class definitions for coverage tracing.
*/
public class Instrumenter {
private final IExecutionDataAccessorGenerator accessGenerator;
/**
* Creates a new instance based on the given runtime.
*
* @param runtime
* runtime used by the instrumented classes
*/
public Instrumenter(final IExecutionDataAccessorGenerator runtime) {
this.accessGenerator = runtime;
}
/**
* Creates a ASM adapter for a class with the given id.
*
* @param classid
* id of the class calculated with {@link CRC64}
* @param cv
* next class visitor in the chain
* @return new visitor to write class definition to
*/
private ClassVisitor createInstrumentingVisitor(final long classid,
final ClassVisitor cv) {
return new ClassProbesAdapter(new ClassInstrumenter(classid,
accessGenerator, cv));
}
/**
* Creates a instrumented version of the given class if possible.
*
* @param reader
* definition of the class as ASM reader
* @return instrumented definition
*
*/
public byte[] instrument(final ClassReader reader) {
final ClassWriter writer = new ClassWriter(reader, 0);
final ClassVisitor visitor = createInstrumentingVisitor(
CRC64.checksum(reader.b), writer);
reader.accept(visitor, ClassReader.EXPAND_FRAMES);
return writer.toByteArray();
}
/**
* Creates a instrumented version of the given class if possible.
*
* @param buffer
* definition of the class
* @return instrumented definition
*
*/
public byte[] instrument(final byte[] buffer) {
return instrument(new ClassReader(buffer));
}
/**
* Creates a instrumented version of the given class if possible.
*
* @param input
* stream to read class definition from
* @return instrumented definition
* @throws IOException
* if reading data from the stream fails
*/
public byte[] instrument(final InputStream input) throws IOException {
return instrument(new ClassReader(input));
}
/**
* Creates a instrumented version of the given class file.
*
* @param input
* stream to read class definition from
* @param output
* stream to write the instrumented version of the class to
* @throws IOException
* if reading data from the stream fails
*/
public void instrument(final InputStream input, final OutputStream output)
throws IOException {
output.write(instrument(new ClassReader(input)));
}
/**
* Creates a instrumented version of the given archive, i.e. with all class
* files contained in this archive instrumented. Contained resources which
* are no class files or archive files are copied as is.
*
* @param input
* stream to read archive from
* @param output
* stream to write the instrumented version of the class to
* @return number of instrumented classes
* @throws IOException
* if reading data from the stream fails
* @deprecated Use {@link #instrumentAll(InputStream, OutputStream)} instead
*/
@Deprecated
public int instrumentArchive(final InputStream input,
final OutputStream output) throws IOException {
return instrumentZip(input, output);
}
/**
* Creates a instrumented version of the given resource depending on its
* type. Class files and the content of archive files are instrumented. All
* other files are copied without modification.
*
* @param input
* stream to contents from
* @param output
* stream to write the instrumented version of the contents
* @return number of instrumented classes
* @throws IOException
* if reading data from the stream fails
*/
public int instrumentAll(final InputStream input, final OutputStream output)
throws IOException {
final ContentTypeDetector detector = new ContentTypeDetector(input);
switch (detector.getType()) {
case ContentTypeDetector.CLASSFILE:
instrument(detector.getInputStream(), output);
return 1;
case ContentTypeDetector.ZIPFILE:
return instrumentZip(detector.getInputStream(), output);
case ContentTypeDetector.GZFILE:
return instrumentGzip(detector.getInputStream(), output);
case ContentTypeDetector.PACK200FILE:
return instrumentPack200(detector.getInputStream(), output);
default:
copy(detector.getInputStream(), output);
return 0;
}
}
private int instrumentZip(final InputStream input, final OutputStream output)
throws IOException {
final ZipInputStream zipin = new ZipInputStream(input);
final ZipOutputStream zipout = new ZipOutputStream(output);
ZipEntry entry;
int count = 0;
while ((entry = zipin.getNextEntry()) != null) {
zipout.putNextEntry(new ZipEntry(entry.getName()));
count += instrumentAll(zipin, zipout);
zipout.closeEntry();
}
zipout.finish();
return count;
}
private int instrumentGzip(final InputStream input,
final OutputStream output) throws IOException {
final GZIPOutputStream gzout = new GZIPOutputStream(output);
final int count = instrumentAll(new GZIPInputStream(input), gzout);
gzout.finish();
return count;
}
private int instrumentPack200(final InputStream input,
final OutputStream output) throws IOException {
final ByteArrayOutputStream buffer = new ByteArrayOutputStream();
final int count = instrumentAll(Pack200Streams.unpack(input), buffer);
Pack200Streams.pack(buffer.toByteArray(), output);
return count;
}
private void copy(final InputStream input, final OutputStream output)
throws IOException {
final byte[] buffer = new byte[1024];
int len;
while ((len = input.read(buffer)) != -1) {
output.write(buffer, 0, len);
}
}
}
|
