1
2
3
4
5
6 package mockit.coverage;
7
8 import edu.umd.cs.findbugs.annotations.NonNull;
9
10 import java.util.concurrent.locks.ReentrantLock;
11
12 import mockit.coverage.data.CoverageData;
13 import mockit.coverage.data.FileCoverageData;
14 import mockit.coverage.lines.PerFileLineCoverage;
15 import mockit.coverage.testRedundancy.TestCoverage;
16
17 import org.checkerframework.checker.index.qual.NonNegative;
18
19 @SuppressWarnings("unused")
20 public final class TestRun {
21 private static final ReentrantLock LOCK = new ReentrantLock();
22 private static boolean terminated;
23
24 private TestRun() {
25 }
26
27 public static void lineExecuted(@NonNegative int fileIndex, @NonNegative int line) {
28 if (terminated) {
29 return;
30 }
31
32 LOCK.lock();
33 try {
34 CoverageData coverageData = CoverageData.instance();
35 PerFileLineCoverage fileData = coverageData.getFileData(fileIndex).lineCoverageInfo;
36 CallPoint callPoint = null;
37
38 if (coverageData.isWithCallPoints() && fileData.acceptsAdditionalCallPoints(line)) {
39 callPoint = CallPoint.create(new Throwable());
40 }
41
42 int previousExecutionCount = fileData.registerExecution(line, callPoint);
43 recordNewLineOrSegmentAsCoveredIfApplicable(previousExecutionCount);
44 } finally {
45 LOCK.unlock();
46 }
47 }
48
49 private static void recordNewLineOrSegmentAsCoveredIfApplicable(@NonNegative int previousExecutionCount) {
50 TestCoverage testCoverage = TestCoverage.INSTANCE;
51
52 if (testCoverage != null) {
53 testCoverage.recordNewItemCoveredByTestIfApplicable(previousExecutionCount);
54 }
55 }
56
57 public static void branchExecuted(@NonNegative int fileIndex, @NonNegative int line, @NonNegative int branchIndex) {
58 if (terminated) {
59 return;
60 }
61
62 LOCK.lock();
63 try {
64 CoverageData coverageData = CoverageData.instance();
65 PerFileLineCoverage fileData = coverageData.getFileData(fileIndex).lineCoverageInfo;
66
67 if (fileData.hasValidBranch(line, branchIndex)) {
68 CallPoint callPoint = null;
69
70 if (coverageData.isWithCallPoints() && fileData.acceptsAdditionalCallPoints(line, branchIndex)) {
71 callPoint = CallPoint.create(new Throwable());
72 }
73
74 int previousExecutionCount = fileData.registerExecution(line, branchIndex, callPoint);
75 recordNewLineOrSegmentAsCoveredIfApplicable(previousExecutionCount);
76 }
77 } finally {
78 LOCK.unlock();
79 }
80 }
81
82 public static void fieldAssigned(@NonNull String file, @NonNull String classAndFieldNames) {
83 if (terminated) {
84 return;
85 }
86
87 LOCK.lock();
88 try {
89 CoverageData coverageData = CoverageData.instance();
90 FileCoverageData fileData = coverageData.getFileData(file);
91 fileData.dataCoverageInfo.registerAssignmentToStaticField(classAndFieldNames);
92 } finally {
93 LOCK.unlock();
94 }
95 }
96
97 public static void fieldRead(@NonNull String file, @NonNull String classAndFieldNames) {
98 if (terminated) {
99 return;
100 }
101
102 LOCK.lock();
103 try {
104 CoverageData coverageData = CoverageData.instance();
105 FileCoverageData fileData = coverageData.getFileData(file);
106 fileData.dataCoverageInfo.registerReadOfStaticField(classAndFieldNames);
107 } finally {
108 LOCK.unlock();
109 }
110 }
111
112 public static void fieldAssigned(@NonNull Object instance, @NonNull String file,
113 @NonNull String classAndFieldNames) {
114 if (terminated) {
115 return;
116 }
117
118 LOCK.lock();
119 try {
120 CoverageData coverageData = CoverageData.instance();
121 FileCoverageData fileData = coverageData.getFileData(file);
122 fileData.dataCoverageInfo.registerAssignmentToInstanceField(instance, classAndFieldNames);
123 } finally {
124 LOCK.unlock();
125 }
126 }
127
128 public static void fieldRead(@NonNull Object instance, @NonNull String file, @NonNull String classAndFieldNames) {
129 if (terminated) {
130 return;
131 }
132
133 LOCK.lock();
134 try {
135 CoverageData coverageData = CoverageData.instance();
136 FileCoverageData fileData = coverageData.getFileData(file);
137 fileData.dataCoverageInfo.registerReadOfInstanceField(instance, classAndFieldNames);
138 } finally {
139 LOCK.unlock();
140 }
141 }
142
143 static void terminate() {
144 terminated = true;
145 }
146
147 public static boolean isTerminated() {
148 return terminated;
149 }
150 }