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