hazendaz / jmockit1 / 876

Committed 24 May 2026 05:47PM UTC coverage: 75.471% (-0.03%) from 75.496%

Build # 876

Build Type

Pull #512

github

Committed by

web-flow

Commit Message

Merge ffde9bbb6 into 19f6c4a1f

Pull Request Pull Request #512: Modernize flagged collection/reflection API usages in `main` module (Java 21 build path)

Coverage Stats

6026 of 8488 branches covered (70.99%)

Branch coverage included in aggregate %.

25 of 34 new or added lines in 15 files covered. (73.53%)

5 existing lines in 1 file now uncovered.

12659 of 16270 relevant lines covered (77.81%)

0.78 hits per line

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

0.0

/main/src/main/java/mockit/coverage/lines/LineCoverageData.java

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

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

import java.util.ArrayList;
import java.util.List;

import mockit.asm.controlFlow.Label;
import mockit.coverage.CallPoint;

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

/**
 * Coverage data gathered for a single executable line of code in a source file.
 */
public final class LineCoverageData extends LineSegmentData {
    private static final long serialVersionUID = -6233980722802474992L;

    // Static data:
    @NonNull
    private List<BranchCoverageData> branches;
    @NonNegative
    private transient int segments;

    LineCoverageData() {
        branches = List.of();
    }

    @NonNegative
    public int addBranchingPoint(@NonNull Label jumpSource, @NonNull Label jumpTarget) {
        int initialIndex = branches.size();

        if (initialIndex == 0) {
            branches = new ArrayList<>(4);
        }

        branches.add(new BranchCoverageData(jumpSource));
        branches.add(new BranchCoverageData(jumpTarget));
        return initialIndex;
    }

    void markLastSegmentAsEmpty() {
        BranchCoverageData lastBranch = branches.get(branches.size() - 1);
        lastBranch.markAsEmpty();
    }

    private boolean noBranchesYet() {
        return branches.isEmpty();
    }

    @NonNull
    public BranchCoverageData getBranchData(@NonNegative int index) {
        return branches.get(index);
    }

    boolean acceptsAdditionalCallPoints(@NonNegative int branchIndex) {
        BranchCoverageData data = branches.get(branchIndex);
        return data.acceptsAdditionalCallPoints();
    }

    @NonNegative
    int registerExecution(@NonNegative int branchIndex, @Nullable CallPoint callPoint) {
        BranchCoverageData data = branches.get(branchIndex);
        return data.registerExecution(callPoint);
    }

    public boolean containsBranches() {
        return !noBranchesYet();
    }

    @NonNull
    public List<BranchCoverageData> getBranches() {
        return branches;
    }

    boolean isValidBranch(@NonNegative int branchIndex) {
        return branches.get(branchIndex) != BranchCoverageData.INVALID;
    }

    @NonNegative
    public int getNumberOfSegments() {
        int previouslyCounted = segments;

        if (previouslyCounted > 0) {
            return previouslyCounted;
        }

        int n = branches.size();
        int count = 1;

        for (int targetBranchIndex = 1; targetBranchIndex < n; targetBranchIndex += 2) {
            BranchCoverageData targetBranch = branches.get(targetBranchIndex);
            int targetLine = targetBranch.getLine();

            if (targetLine > 0) {
                BranchCoverageData sourceBranch = branches.get(targetBranchIndex - 1);
                int sourceLine = sourceBranch.getLine();

                if (targetLine == sourceLine) {
                    count++;
                }

                if (!targetBranch.isEmpty()) {
                    count++;
                }
            }
        }

        segments = count;
        return count;
    }

    @NonNegative
    public int getNumberOfCoveredSegments() {
        int segmentsCovered = isCovered() ? 1 : 0;
        int n = branches.size();

        if (n == 0) {
            return segmentsCovered;
        }

        for (int sourceBranchIndex = 0; sourceBranchIndex < n; sourceBranchIndex += 2) {
            BranchCoverageData sourceBranch = branches.get(sourceBranchIndex);
            BranchCoverageData targetBranch = branches.get(sourceBranchIndex + 1);

            if (sourceBranch.isCovered() && !targetBranch.isEmpty()) {
                segmentsCovered++;
            }

            if (targetBranch.isCovered()) {
                int targetLine = targetBranch.getLine();

                if (targetLine == sourceBranch.getLine()) {
                    segmentsCovered++;
                }
            }
        }

        return segmentsCovered;
    }

    @NonNegative
    public int getNumberOfBranchingSourcesAndTargets() {
        int n = branches.size();

        if (n == 0) {
            return 0;
        }

        int count = 0;

        for (int sourceBranchIndex = 0; sourceBranchIndex < n; sourceBranchIndex += 2) {
            BranchCoverageData sourceBranch = branches.get(sourceBranchIndex);

            if (!sourceBranch.isEmpty()) {
                count++;
            }

            count++;
        }

        return count;
    }

    @NonNegative
    public int getNumberOfCoveredBranchingSourcesAndTargets() {
        int n = branches.size();

        if (n == 0) {
            return 0;
        }

        int sourcesAndTargetsCovered = 0;

        for (int sourceBranchIndex = 0; sourceBranchIndex < n; sourceBranchIndex += 2) {
            BranchCoverageData sourceBranch = branches.get(sourceBranchIndex);
            BranchCoverageData targetBranch = branches.get(sourceBranchIndex + 1);

            if (sourceBranch.isCovered()) {
                sourcesAndTargetsCovered++;
            }

            if (targetBranch.isCovered()) {
                int targetLine = targetBranch.getLine();

                if (targetLine == sourceBranch.getLine()) {
                    sourcesAndTargetsCovered++;
                }
            }
        }

        return sourcesAndTargetsCovered;
    }

    void addCountsFromPreviousTestRun(@NonNull LineCoverageData previousData) {
        addExecutionCountAndCallPointsFromPreviousTestRun(previousData);

        if (containsBranches()) {
            for (int i = 0, n = branches.size(); i < n; i++) {
                BranchCoverageData segmentData = branches.get(i);
                BranchCoverageData previousSegmentData = previousData.branches.get(i);

                segmentData.addExecutionCountAndCallPointsFromPreviousTestRun(previousSegmentData);
            }
        }
    }
}

1	/*
2	* MIT License
3	* Copyright (c) 2006-2025 JMockit developers
4	* See LICENSE file for full license text.
5	*/
6	package mockit.coverage.lines;
7
8	import edu.umd.cs.findbugs.annotations.NonNull;
9	import edu.umd.cs.findbugs.annotations.Nullable;
10
11	import java.util.ArrayList;
12	import java.util.List;
13
14	import mockit.asm.controlFlow.Label;
15	import mockit.coverage.CallPoint;
16
17	import org.checkerframework.checker.index.qual.NonNegative;
18
19	/**
20	* Coverage data gathered for a single executable line of code in a source file.
21	*/
22	public final class LineCoverageData extends LineSegmentData {
23	private static final long serialVersionUID = -6233980722802474992L;
24
25	// Static data:
26	@NonNull
27	private List<BranchCoverageData> branches;
28	@NonNegative
29	private transient int segments;
30
31	LineCoverageData() {	×
NEW 32	branches = List.of();	×
33	}	×
34
35	@NonNegative
36	public int addBranchingPoint(@NonNull Label jumpSource, @NonNull Label jumpTarget) {
37	int initialIndex = branches.size();	×
38
39	if (initialIndex == 0) {	×
40	branches = new ArrayList<>(4);	×
41	}
42
43	branches.add(new BranchCoverageData(jumpSource));	×
44	branches.add(new BranchCoverageData(jumpTarget));	×
45	return initialIndex;	×
46	}
47
48	void markLastSegmentAsEmpty() {
49	BranchCoverageData lastBranch = branches.get(branches.size() - 1);	×
50	lastBranch.markAsEmpty();	×
51	}	×
52
53	private boolean noBranchesYet() {
NEW 54	return branches.isEmpty();	×
55	}
56
57	@NonNull
58	public BranchCoverageData getBranchData(@NonNegative int index) {
59	return branches.get(index);	×
60	}
61
62	boolean acceptsAdditionalCallPoints(@NonNegative int branchIndex) {
63	BranchCoverageData data = branches.get(branchIndex);	×
64	return data.acceptsAdditionalCallPoints();	×
65	}
66
67	@NonNegative
68	int registerExecution(@NonNegative int branchIndex, @Nullable CallPoint callPoint) {
69	BranchCoverageData data = branches.get(branchIndex);	×
70	return data.registerExecution(callPoint);	×
71	}
72
73	public boolean containsBranches() {
74	return !noBranchesYet();	×
75	}
76
77	@NonNull
78	public List<BranchCoverageData> getBranches() {
79	return branches;	×
80	}
81
82	boolean isValidBranch(@NonNegative int branchIndex) {
83	return branches.get(branchIndex) != BranchCoverageData.INVALID;	×
84	}
85
86	@NonNegative
87	public int getNumberOfSegments() {
88	int previouslyCounted = segments;	×
89
90	if (previouslyCounted > 0) {	×
91	return previouslyCounted;	×
92	}
93
94	int n = branches.size();	×
95	int count = 1;	×
96
97	for (int targetBranchIndex = 1; targetBranchIndex < n; targetBranchIndex += 2) {	×
98	BranchCoverageData targetBranch = branches.get(targetBranchIndex);	×
99	int targetLine = targetBranch.getLine();	×
100
101	if (targetLine > 0) {	×
102	BranchCoverageData sourceBranch = branches.get(targetBranchIndex - 1);	×
103	int sourceLine = sourceBranch.getLine();	×
104
105	if (targetLine == sourceLine) {	×
106	count++;	×
107	}
108
109	if (!targetBranch.isEmpty()) {	×
110	count++;	×
111	}
112	}
113	}
114
115	segments = count;	×
116	return count;	×
117	}
118
119	@NonNegative
120	public int getNumberOfCoveredSegments() {
121	int segmentsCovered = isCovered() ? 1 : 0;	×
122	int n = branches.size();	×
123
124	if (n == 0) {	×
125	return segmentsCovered;	×
126	}
127
128	for (int sourceBranchIndex = 0; sourceBranchIndex < n; sourceBranchIndex += 2) {	×
129	BranchCoverageData sourceBranch = branches.get(sourceBranchIndex);	×
130	BranchCoverageData targetBranch = branches.get(sourceBranchIndex + 1);	×
131
132	if (sourceBranch.isCovered() && !targetBranch.isEmpty()) {	×
133	segmentsCovered++;	×
134	}
135
136	if (targetBranch.isCovered()) {	×
137	int targetLine = targetBranch.getLine();	×
138
139	if (targetLine == sourceBranch.getLine()) {	×
140	segmentsCovered++;	×
141	}
142	}
143	}
144
145	return segmentsCovered;	×
146	}
147
148	@NonNegative
149	public int getNumberOfBranchingSourcesAndTargets() {
150	int n = branches.size();	×
151
152	if (n == 0) {	×
153	return 0;	×
154	}
155
156	int count = 0;	×
157
158	for (int sourceBranchIndex = 0; sourceBranchIndex < n; sourceBranchIndex += 2) {	×
159	BranchCoverageData sourceBranch = branches.get(sourceBranchIndex);	×
160
161	if (!sourceBranch.isEmpty()) {	×
162	count++;	×
163	}
164
165	count++;	×
166	}
167
168	return count;	×
169	}
170
171	@NonNegative
172	public int getNumberOfCoveredBranchingSourcesAndTargets() {
173	int n = branches.size();	×
174
175	if (n == 0) {	×
176	return 0;	×
177	}
178
179	int sourcesAndTargetsCovered = 0;	×
180
181	for (int sourceBranchIndex = 0; sourceBranchIndex < n; sourceBranchIndex += 2) {	×
182	BranchCoverageData sourceBranch = branches.get(sourceBranchIndex);	×
183	BranchCoverageData targetBranch = branches.get(sourceBranchIndex + 1);	×
184
185	if (sourceBranch.isCovered()) {	×
186	sourcesAndTargetsCovered++;	×
187	}
188
189	if (targetBranch.isCovered()) {	×
190	int targetLine = targetBranch.getLine();	×
191
192	if (targetLine == sourceBranch.getLine()) {	×
193	sourcesAndTargetsCovered++;	×
194	}
195	}
196	}
197
198	return sourcesAndTargetsCovered;	×
199	}
200
201	void addCountsFromPreviousTestRun(@NonNull LineCoverageData previousData) {
202	addExecutionCountAndCallPointsFromPreviousTestRun(previousData);	×
203
204	if (containsBranches()) {	×
205	for (int i = 0, n = branches.size(); i < n; i++) {	×
206	BranchCoverageData segmentData = branches.get(i);	×
207	BranchCoverageData previousSegmentData = previousData.branches.get(i);	×
208
209	segmentData.addExecutionCountAndCallPointsFromPreviousTestRun(previousSegmentData);	×
210	}
211	}
212	}	×
213	}

hazendaz / jmockit1 / 876

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