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

85.71

/main/src/main/java/mockit/internal/util/MethodFormatter.java

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

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

import java.util.ArrayList;
import java.util.List;
import java.util.regex.Pattern;

import mockit.internal.state.ParameterNames;

public final class MethodFormatter {
    private static final Pattern CONSTRUCTOR_NAME = Pattern.compile("<init>");
    private static final Pattern JAVA_LANG_PREFIX = Pattern.compile("java/lang/");

    @NonNull
    private final StringBuilder out;
    @NonNull
    private final List<String> parameterTypes;
    @NonNull
    private final String classDesc;
    @NonNull
    private String methodDesc;

    // Auxiliary fields for handling method parameters:
    private int parameterIndex;
    private int typeDescPos;
    private char typeCode;
    private int arrayDimensions;

    public MethodFormatter(@Nullable String classDesc) {
        out = new StringBuilder();
        parameterTypes = new ArrayList<>(5);
        this.classDesc = classDesc;
        methodDesc = "";
    }

    public MethodFormatter(@NonNull String classDesc, @NonNull String methodNameAndDesc) {
        this(classDesc, methodNameAndDesc, true);
    }

    public MethodFormatter(@NonNull String classDesc, @NonNull String methodNameAndDesc,
            boolean withParametersAppended) {
        out = new StringBuilder();
        parameterTypes = new ArrayList<>(5);
        this.classDesc = classDesc;
        methodDesc = "";
        methodDesc = methodNameAndDesc;
        appendFriendlyMethodSignature(withParametersAppended);
    }

    @Override
    public String toString() {
        return out.toString();
    }

    @NonNull
    public List<String> getParameterTypes() {
        return parameterTypes;
    }

    private void appendFriendlyMethodSignature(boolean withParametersAppended) {
        String className = classDesc.replace('/', '.');
        out.append(className).append('#');

        String constructorName = getConstructorName(className);
        String friendlyDesc = CONSTRUCTOR_NAME.matcher(methodDesc).replaceFirst(constructorName);

        int leftParenNextPos = friendlyDesc.indexOf('(') + 1;
        int rightParenPos = friendlyDesc.indexOf(')');

        if (leftParenNextPos < rightParenPos) {
            out.append(friendlyDesc, 0, leftParenNextPos);

            String concatenatedParameterTypes = friendlyDesc.substring(leftParenNextPos, rightParenPos);

            if (withParametersAppended) {
                parameterIndex = 0;
                appendParameterTypesAndNames(concatenatedParameterTypes);
                out.append(')');
            } else {
                addParameterTypes(concatenatedParameterTypes);
            }
        } else {
            out.append(friendlyDesc, 0, rightParenPos + 1);
        }
    }

    @NonNull
    private static String getConstructorName(@NonNull String className) {
        int p = className.lastIndexOf('.');
        String constructorName = p < 0 ? className : className.substring(p + 1);

        // noinspection ReuseOfLocalVariable
        p = constructorName.lastIndexOf('$');

        if (p > 0) {
            constructorName = constructorName.substring(p + 1);
        }

        return constructorName;
    }

    private void appendParameterTypesAndNames(@NonNull String typeDescs) {
        String sep = "";

        for (String typeDesc : typeDescs.split(";")) {
            out.append(sep);

            if (typeDesc.charAt(0) == 'L') {
                appendParameterType(friendlyReferenceType(typeDesc));
                appendParameterName();
            } else {
                appendPrimitiveParameterTypesAndNames(typeDesc);
            }

            sep = ", ";
        }
    }

    @NonNull
    private static String friendlyReferenceType(@NonNull String typeDesc) {
        return JAVA_LANG_PREFIX.matcher(typeDesc.substring(1)).replaceAll("").replace('/', '.');
    }

    private void appendParameterType(@NonNull String friendlyTypeDesc) {
        out.append(friendlyTypeDesc);
        parameterTypes.add(friendlyTypeDesc);
    }

    private void appendParameterName() {
        String name = ParameterNames.getName(classDesc, methodDesc, parameterIndex);

        if (name != null) {
            out.append(' ').append(name);
        }

        parameterIndex++;
    }

    private void appendPrimitiveParameterTypesAndNames(@NonNull String typeDesc) {
        String sep = "";

        for (typeDescPos = 0; typeDescPos < typeDesc.length(); typeDescPos++) {
            typeCode = typeDesc.charAt(typeDescPos);
            advancePastArrayDimensionsIfAny(typeDesc);

            out.append(sep);

            String paramType = getTypeNameForTypeDesc(typeDesc) + getArrayBrackets();
            appendParameterType(paramType);
            appendParameterName();

            sep = ", ";
        }
    }

    private void addParameterTypes(@NonNull String typeDescs) {
        for (String typeDesc : typeDescs.split(";")) {
            if (typeDesc.charAt(0) == 'L') {
                parameterTypes.add(friendlyReferenceType(typeDesc));
            } else {
                addPrimitiveParameterTypes(typeDesc);
            }
        }
    }

    private void addPrimitiveParameterTypes(@NonNull String typeDesc) {
        for (typeDescPos = 0; typeDescPos < typeDesc.length(); typeDescPos++) {
            typeCode = typeDesc.charAt(typeDescPos);
            advancePastArrayDimensionsIfAny(typeDesc);

            String paramType = getTypeNameForTypeDesc(typeDesc) + getArrayBrackets();
            parameterTypes.add(paramType);
        }
    }

    @NonNull
    @SuppressWarnings("OverlyComplexMethod")
    private String getTypeNameForTypeDesc(@NonNull String typeDesc) {
        String paramType;

        switch (typeCode) {
            case 'B':
                return "byte";
            case 'C':
                return "char";
            case 'D':
                return "double";
            case 'F':
                return "float";
            case 'I':
                return "int";
            case 'J':
                return "long";
            case 'S':
                return "short";
            case 'V':
                return "void";
            case 'Z':
                return "boolean";
            case 'L':
                paramType = friendlyReferenceType(typeDesc.substring(typeDescPos));
                typeDescPos = typeDesc.length();
                break;
            default:
                paramType = typeDesc.substring(typeDescPos);
                typeDescPos = typeDesc.length();
        }

        return paramType;
    }

    private void advancePastArrayDimensionsIfAny(@NonNull String param) {
        arrayDimensions = 0;

        while (typeCode == '[') {
            typeDescPos++;
            typeCode = param.charAt(typeDescPos);
            arrayDimensions++;
        }
    }

    @NonNull
    private String getArrayBrackets() {
        @SuppressWarnings("NonConstantStringShouldBeStringBuffer")
        StringBuilder result = new StringBuilder();

        for (int i = 0; i < arrayDimensions; i++) {
            // noinspection StringContatenationInLoop
            result.append("[]");
        }

        return result.toString();
    }

    public void append(@NonNull String text) {
        out.append(text);
    }
}

1	/*
2	* MIT License
3	* Copyright (c) 2006-2025 JMockit developers
4	* See LICENSE file for full license text.
5	*/
6	package mockit.internal.util;
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	import java.util.regex.Pattern;
14
15	import mockit.internal.state.ParameterNames;
16
17	public final class MethodFormatter {
18	private static final Pattern CONSTRUCTOR_NAME = Pattern.compile("<init>");	1✔
19	private static final Pattern JAVA_LANG_PREFIX = Pattern.compile("java/lang/");	1✔
20
21	@NonNull
22	private final StringBuilder out;
23	@NonNull
24	private final List<String> parameterTypes;
25	@NonNull
26	private final String classDesc;
27	@NonNull
28	private String methodDesc;
29
30	// Auxiliary fields for handling method parameters:
31	private int parameterIndex;
32	private int typeDescPos;
33	private char typeCode;
34	private int arrayDimensions;
35
36	public MethodFormatter(@Nullable String classDesc) {	×
37	out = new StringBuilder();	×
38	parameterTypes = new ArrayList<>(5);	×
39	this.classDesc = classDesc;	×
40	methodDesc = "";	×
41	}	×
42
43	public MethodFormatter(@NonNull String classDesc, @NonNull String methodNameAndDesc) {
44	this(classDesc, methodNameAndDesc, true);	1✔
45	}	1✔
46
47	public MethodFormatter(@NonNull String classDesc, @NonNull String methodNameAndDesc,
48	boolean withParametersAppended) {	1✔
49	out = new StringBuilder();	1✔
50	parameterTypes = new ArrayList<>(5);	1✔
51	this.classDesc = classDesc;	1✔
52	methodDesc = "";	1✔
53	methodDesc = methodNameAndDesc;	1✔
54	appendFriendlyMethodSignature(withParametersAppended);	1✔
55	}	1✔
56
57	@Override
58	public String toString() {
59	return out.toString();	1✔
60	}
61
62	@NonNull
63	public List<String> getParameterTypes() {
64	return parameterTypes;	1✔
65	}
66
67	private void appendFriendlyMethodSignature(boolean withParametersAppended) {
68	String className = classDesc.replace('/', '.');	1✔
69	out.append(className).append('#');	1✔
70
71	String constructorName = getConstructorName(className);	1✔
72	String friendlyDesc = CONSTRUCTOR_NAME.matcher(methodDesc).replaceFirst(constructorName);	1✔
73
74	int leftParenNextPos = friendlyDesc.indexOf('(') + 1;	1✔
75	int rightParenPos = friendlyDesc.indexOf(')');	1✔
76
77	if (leftParenNextPos < rightParenPos) {	1✔
78	out.append(friendlyDesc, 0, leftParenNextPos);	1✔
79
80	String concatenatedParameterTypes = friendlyDesc.substring(leftParenNextPos, rightParenPos);	1✔
81
82	if (withParametersAppended) {	1✔
83	parameterIndex = 0;	1✔
84	appendParameterTypesAndNames(concatenatedParameterTypes);	1✔
85	out.append(')');	1✔
86	} else {
87	addParameterTypes(concatenatedParameterTypes);	1✔
88	}
89	} else {	1✔
90	out.append(friendlyDesc, 0, rightParenPos + 1);	1✔
91	}
92	}	1✔
93
94	@NonNull
95	private static String getConstructorName(@NonNull String className) {
96	int p = className.lastIndexOf('.');	1✔
97	String constructorName = p < 0 ? className : className.substring(p + 1);	1!
98
99	// noinspection ReuseOfLocalVariable
100	p = constructorName.lastIndexOf('$');	1✔
101
102	if (p > 0) {	1✔
103	constructorName = constructorName.substring(p + 1);	1✔
104	}
105
106	return constructorName;	1✔
107	}
108
109	private void appendParameterTypesAndNames(@NonNull String typeDescs) {
110	String sep = "";	1✔
111
112	for (String typeDesc : typeDescs.split(";")) {	1✔
113	out.append(sep);	1✔
114
115	if (typeDesc.charAt(0) == 'L') {	1✔
116	appendParameterType(friendlyReferenceType(typeDesc));	1✔
117	appendParameterName();	1✔
118	} else {
119	appendPrimitiveParameterTypesAndNames(typeDesc);	1✔
120	}
121
122	sep = ", ";	1✔
123	}
124	}	1✔
125
126	@NonNull
127	private static String friendlyReferenceType(@NonNull String typeDesc) {
128	return JAVA_LANG_PREFIX.matcher(typeDesc.substring(1)).replaceAll("").replace('/', '.');	1✔
129	}
130
131	private void appendParameterType(@NonNull String friendlyTypeDesc) {
132	out.append(friendlyTypeDesc);	1✔
133	parameterTypes.add(friendlyTypeDesc);	1✔
134	}	1✔
135
136	private void appendParameterName() {
137	String name = ParameterNames.getName(classDesc, methodDesc, parameterIndex);	1✔
138
139	if (name != null) {	1!
140	out.append(' ').append(name);	1✔
141	}
142
143	parameterIndex++;	1✔
144	}	1✔
145
146	private void appendPrimitiveParameterTypesAndNames(@NonNull String typeDesc) {
147	String sep = "";	1✔
148
149	for (typeDescPos = 0; typeDescPos < typeDesc.length(); typeDescPos++) {	1✔
150	typeCode = typeDesc.charAt(typeDescPos);	1✔
151	advancePastArrayDimensionsIfAny(typeDesc);	1✔
152
153	out.append(sep);	1✔
154
155	String paramType = getTypeNameForTypeDesc(typeDesc) + getArrayBrackets();	1✔
156	appendParameterType(paramType);	1✔
157	appendParameterName();	1✔
158
159	sep = ", ";	1✔
160	}
161	}	1✔
162
163	private void addParameterTypes(@NonNull String typeDescs) {
164	for (String typeDesc : typeDescs.split(";")) {	1✔
165	if (typeDesc.charAt(0) == 'L') {	1✔
166	parameterTypes.add(friendlyReferenceType(typeDesc));	1✔
167	} else {
168	addPrimitiveParameterTypes(typeDesc);	1✔
169	}
170	}
171	}	1✔
172
173	private void addPrimitiveParameterTypes(@NonNull String typeDesc) {
174	for (typeDescPos = 0; typeDescPos < typeDesc.length(); typeDescPos++) {	1✔
175	typeCode = typeDesc.charAt(typeDescPos);	1✔
176	advancePastArrayDimensionsIfAny(typeDesc);	1✔
177
178	String paramType = getTypeNameForTypeDesc(typeDesc) + getArrayBrackets();	1✔
179	parameterTypes.add(paramType);	1✔
180	}
181	}	1✔
182
183	@NonNull
184	@SuppressWarnings("OverlyComplexMethod")
185	private String getTypeNameForTypeDesc(@NonNull String typeDesc) {
186	String paramType;
187
188	switch (typeCode) {	1!
189	case 'B':
190	return "byte";	×
191	case 'C':
192	return "char";	1✔
193	case 'D':
194	return "double";	1✔
195	case 'F':
196	return "float";	×
197	case 'I':
198	return "int";	1✔
199	case 'J':
200	return "long";	×
201	case 'S':
202	return "short";	×
203	case 'V':
204	return "void";	×
205	case 'Z':
206	return "boolean";	1✔
207	case 'L':
208	paramType = friendlyReferenceType(typeDesc.substring(typeDescPos));	1✔
209	typeDescPos = typeDesc.length();	1✔
210	break;	1✔
211	default:
212	paramType = typeDesc.substring(typeDescPos);	×
213	typeDescPos = typeDesc.length();	×
214	}
215
216	return paramType;	1✔
217	}
218
219	private void advancePastArrayDimensionsIfAny(@NonNull String param) {
220	arrayDimensions = 0;	1✔
221
222	while (typeCode == '[') {	1✔
223	typeDescPos++;	1✔
224	typeCode = param.charAt(typeDescPos);	1✔
225	arrayDimensions++;	1✔
226	}
227	}	1✔
228
229	@NonNull
230	private String getArrayBrackets() {
231	@SuppressWarnings("NonConstantStringShouldBeStringBuffer")
232	StringBuilder result = new StringBuilder();	1✔
233
234	for (int i = 0; i < arrayDimensions; i++) {	1✔
235	// noinspection StringContatenationInLoop
236	result.append("[]");	1✔
237	}
238
239	return result.toString();	1✔
240	}
241
242	public void append(@NonNull String text) {
243	out.append(text);	1✔
244	}	1✔
245	}

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