hazendaz / jmockit1 / 496

Committed 15 Nov 2025 05:33PM UTC coverage: 72.192% (-0.008%) from 72.2%

Build # 496

Build Type

push

github

Committed by

web-flow

Commit Message

Merge pull request #412 from hazendaz/renovate/major-spring-core

Update spring core to v7 (major)

Run Details

5677 of 8360 branches covered (67.91%)

Branch coverage included in aggregate %.

11922 of 16018 relevant lines covered (74.43%)

0.74 hits per line

Source File
Press 'n' to go to next uncovered line, 'b' for previous

0.0

/main/src/main/java/mockit/coverage/TestRun.java

/*
 * MIT License
 * Copyright (c) 2006-2025 JMockit developers
 * See LICENSE file for full license text.
 */
package mockit.coverage;

import edu.umd.cs.findbugs.annotations.NonNull;

import java.util.concurrent.locks.ReentrantLock;

import mockit.coverage.data.CoverageData;
import mockit.coverage.data.FileCoverageData;
import mockit.coverage.lines.PerFileLineCoverage;
import mockit.coverage.testRedundancy.TestCoverage;

import org.checkerframework.checker.index.qual.NonNegative;

@SuppressWarnings("unused")
public final class TestRun {
    private static final ReentrantLock LOCK = new ReentrantLock();
    private static boolean terminated;

    private TestRun() {
    }

    public static void lineExecuted(@NonNegative int fileIndex, @NonNegative int line) {
        if (terminated) {
            return;
        }

        LOCK.lock();
        try {
            CoverageData coverageData = CoverageData.instance();
            PerFileLineCoverage fileData = coverageData.getFileData(fileIndex).lineCoverageInfo;
            CallPoint callPoint = null;

            if (coverageData.isWithCallPoints() && fileData.acceptsAdditionalCallPoints(line)) {
                callPoint = CallPoint.create(new Throwable());
            }

            int previousExecutionCount = fileData.registerExecution(line, callPoint);
            recordNewLineOrSegmentAsCoveredIfApplicable(previousExecutionCount);
        } finally {
            LOCK.unlock();
        }
    }

    private static void recordNewLineOrSegmentAsCoveredIfApplicable(@NonNegative int previousExecutionCount) {
        TestCoverage testCoverage = TestCoverage.INSTANCE;

        if (testCoverage != null) {
            testCoverage.recordNewItemCoveredByTestIfApplicable(previousExecutionCount);
        }
    }

    public static void branchExecuted(@NonNegative int fileIndex, @NonNegative int line, @NonNegative int branchIndex) {
        if (terminated) {
            return;
        }

        LOCK.lock();
        try {
            CoverageData coverageData = CoverageData.instance();
            PerFileLineCoverage fileData = coverageData.getFileData(fileIndex).lineCoverageInfo;

            if (fileData.hasValidBranch(line, branchIndex)) {
                CallPoint callPoint = null;

                if (coverageData.isWithCallPoints() && fileData.acceptsAdditionalCallPoints(line, branchIndex)) {
                    callPoint = CallPoint.create(new Throwable());
                }

                int previousExecutionCount = fileData.registerExecution(line, branchIndex, callPoint);
                recordNewLineOrSegmentAsCoveredIfApplicable(previousExecutionCount);
            }
        } finally {
            LOCK.unlock();
        }
    }

    public static void fieldAssigned(@NonNull String file, @NonNull String classAndFieldNames) {
        if (terminated) {
            return;
        }

        LOCK.lock();
        try {
            CoverageData coverageData = CoverageData.instance();
            FileCoverageData fileData = coverageData.getFileData(file);
            fileData.dataCoverageInfo.registerAssignmentToStaticField(classAndFieldNames);
        } finally {
            LOCK.unlock();
        }
    }

    public static void fieldRead(@NonNull String file, @NonNull String classAndFieldNames) {
        if (terminated) {
            return;
        }

        LOCK.lock();
        try {
            CoverageData coverageData = CoverageData.instance();
            FileCoverageData fileData = coverageData.getFileData(file);
            fileData.dataCoverageInfo.registerReadOfStaticField(classAndFieldNames);
        } finally {
            LOCK.unlock();
        }
    }

    public static void fieldAssigned(@NonNull Object instance, @NonNull String file,
            @NonNull String classAndFieldNames) {
        if (terminated) {
            return;
        }

        LOCK.lock();
        try {
            CoverageData coverageData = CoverageData.instance();
            FileCoverageData fileData = coverageData.getFileData(file);
            fileData.dataCoverageInfo.registerAssignmentToInstanceField(instance, classAndFieldNames);
        } finally {
            LOCK.unlock();
        }
    }

    public static void fieldRead(@NonNull Object instance, @NonNull String file, @NonNull String classAndFieldNames) {
        if (terminated) {
            return;
        }

        LOCK.lock();
        try {
            CoverageData coverageData = CoverageData.instance();
            FileCoverageData fileData = coverageData.getFileData(file);
            fileData.dataCoverageInfo.registerReadOfInstanceField(instance, classAndFieldNames);
        } finally {
            LOCK.unlock();
        }
    }

    static void terminate() {
        terminated = true;
    }

    public static boolean isTerminated() {
        return terminated;
    }
}

1	/*
2	* MIT License
3	* Copyright (c) 2006-2025 JMockit developers
4	* See LICENSE file for full license text.
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	}

hazendaz / jmockit1 / 496

Source File Press 'n' to go to next uncovered line, 'b' for previous

Source File
Press 'n' to go to next uncovered line, 'b' for previous