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
|
// BEGIN android-change
package org.jacoco.core.data;
import java.io.IOException;
import java.nio.channels.FileChannel;
/**
* Class that delegates calls to {@link IExecutionData} interface methods to another instance.
* Also has the ability to convert the underlying implementation to a {@link MappedExecutionData}
* instance.
*/
public class ExecutionDataDelegate implements IExecutionData {
private IExecutionData delegate;
public ExecutionDataDelegate(
final long id, final String name, final int probeCount, final FileChannel channel) {
if ((channel != null) && canMapData(name)) {
try {
delegate = new MappedExecutionData(id, name, probeCount, channel);
} catch (IOException e) {
delegate = new ExecutionData(id, name, probeCount);
}
} else {
delegate = new ExecutionData(id, name, probeCount);
}
}
/**
* Converts the existing delegate into a {@link MappedExecutionData} instance if it is not
* already one, and copies any probe data into the new instance.
*/
public synchronized void convert(final FileChannel channel) throws IOException {
if (!(delegate instanceof MappedExecutionData) && canMapData(getName())) {
IExecutionData newDelegate = new MappedExecutionData(
getId(), getName(), getProbeCount(), channel);
newDelegate.merge(delegate);
delegate = newDelegate;
}
}
/**
* Determines if a class can be converted to memory-mapped.
*/
private static boolean canMapData(final String name) {
if (name.startsWith("android/app/")
|| name.startsWith("android/os/")
|| name.startsWith("com/android/internal/util/")
|| name.startsWith("java/")) {
return false;
}
return true;
}
/**
* Return the unique identifier for this class. The identifier is the CRC64
* checksum of the raw class file definition.
*
* @return class identifier
*/
public long getId() {
return delegate.getId();
}
/**
* The VM name of the class.
*
* @return VM name
*/
public String getName() {
return delegate.getName();
}
/**
* The number of instrumentation probes for this class.
*
* @return number of probes
*/
public int getProbeCount() {
return delegate.getProbeCount();
}
/**
* Returns a copy of the probe data as a boolean array.
*
* Changes to the returned array will not be reflected in the execution data.
*
* @return copy of the probe data
*/
public boolean[] getProbesCopy() {
return delegate.getProbesCopy();
}
/**
* Sets all probes to <code>false</code>.
*/
public void reset() {
delegate.reset();
}
/**
* Checks whether any probe has been hit.
*
* @return <code>true</code>, if at least one probe has been hit
*/
public boolean hasHits() {
return delegate.hasHits();
}
/**
* Merges the given execution data into the probe data of this object. I.e.
* a probe entry in this object is marked as executed (<code>true</code>) if
* this probe or the corresponding other probe was executed. So the result
* is
*
* <pre>
* A or B
* </pre>
*
* The probe array of the other object is not modified.
*
* @param other
* execution data to merge
*/
public void merge(final IExecutionData other) {
delegate.merge(other);
}
/**
* Merges the given execution data into the probe data of this object. A
* probe in this object is set to the value of <code>flag</code> if the
* corresponding other probe was executed. For <code>flag==true</code> this
* corresponds to
*
* <pre>
* A or B
* </pre>
*
* For <code>flag==false</code> this can be considered as a subtraction
*
* <pre>
* A and not B
* </pre>
*
* The probe array of the other object is not modified.
*
* @param other
* execution data to merge
* @param flag
* merge mode
*/
public void merge(final IExecutionData other, boolean flag) {
delegate.merge(other, flag);
}
/**
* Asserts that this execution data object is compatible with the given
* parameters. The purpose of this check is to detect a very unlikely class
* id collision.
*
* @param id
* other class id, must be the same
* @param name
* other name, must be equal to this name
* @param probecount
* probe data length, must be the same as for this data
* @throws IllegalStateException
* if the given parameters do not match this instance
*/
public void assertCompatibility(final long id, final String name, final int probeCount)
throws IllegalStateException {
delegate.assertCompatibility(id, name, probeCount);
}
/**
* Returns the execution data probe for a given index. A value of
* <code>true</code> indicates that the corresponding probe was
* executed.
*
* @param index the probe's index to look up
*
* @return probe data
*/
public boolean getProbe(final int index) {
return delegate.getProbe(index);
}
/**
* Sets the execution data probe at the given index to <code>true</code>.
*
* @param index the probe's index to set
* @param value the value to set the probe to
*/
public void setProbe(final int index) {
delegate.setProbe(index);
}
}
// END android-change
|
