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)

Coverage Stats

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

76.98

/main/src/main/java/mockit/internal/expectations/argumentMatching/ArgumentMismatch.java

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

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

import java.lang.reflect.Array;
import java.lang.reflect.Method;

import mockit.internal.util.ObjectMethods;

public final class ArgumentMismatch {
    @NonNull
    private final StringBuilder out = new StringBuilder(50);
    @Nullable
    private String parameterType;

    @Nullable
    public String getParameterType() {
        return parameterType;
    }

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

    @NonNull
    public ArgumentMismatch append(char c) {
        out.append(c);
        return this;
    }

    @NonNull
    public ArgumentMismatch append(int i) {
        out.append(i);
        return this;
    }

    @NonNull
    public ArgumentMismatch append(double d) {
        out.append(d);
        return this;
    }

    @NonNull
    public ArgumentMismatch append(@Nullable CharSequence str) {
        out.append(str);
        return this;
    }

    public void appendFormatted(@Nullable String parameterTypeName, @Nullable Object argumentValue,
            @Nullable ArgumentMatcher<?> matcher) {
        if (matcher == null) {
            appendFormatted(argumentValue);
        } else {
            parameterType = parameterTypeName;
            matcher.writeMismatchPhrase(this);
        }
    }

    @SuppressWarnings("OverlyComplexMethod")
    void appendFormatted(@Nullable Object value) {
        if (value == null) {
            out.append("null");
        } else if (value instanceof CharSequence) {
            appendCharacters((CharSequence) value);
        } else if (value instanceof Character) {
            out.append('\'');
            appendEscapedOrPlainCharacter('\'', (Character) value);
            out.append('\'');
        } else if (value instanceof Byte) {
            out.append(value).append('b');
        } else if (value instanceof Short) {
            out.append(value).append('s');
        } else if (value instanceof Long) {
            out.append(value).append('L');
        } else if (value instanceof Float) {
            out.append(value).append('F');
        } else if (value instanceof Number || value instanceof Boolean) {
            out.append(value);
        } else if (value.getClass().isArray()) {
            appendArray(value);
        } else if (value instanceof ArgumentMatcher) {
            ((ArgumentMatcher<?>) value).writeMismatchPhrase(this);
        } else {
            appendArbitraryArgument(value);
        }
    }

    private void appendArray(@NonNull Object array) {
        out.append('[');
        String separator = "";

        for (int i = 0, n = Array.getLength(array); i < n; i++) {
            Object nextValue = Array.get(array, i);
            out.append(separator);
            appendFormatted(nextValue);
            separator = ", ";
        }

        out.append(']');
    }

    private void appendCharacters(@NonNull CharSequence characters) {
        out.append('"');

        for (int i = 0, n = characters.length(); i < n; i++) {
            char c = characters.charAt(i);
            appendEscapedOrPlainCharacter('"', c);
        }

        out.append('"');
    }

    private void appendEscapedOrPlainCharacter(char quoteCharacter, char c) {
        if (c == quoteCharacter) {
            out.append('\\').append(c);
        } else {
            switch (c) {
                case '\t':
                    out.append("\\t");
                    break;
                case '\n':
                    out.append("\\n");
                    break;
                case '\r':
                    out.append("\\r");
                    break;
                default:
                    out.append(c);
            }
        }
    }

    private void appendArbitraryArgument(@NonNull Object value) {
        Class<?> valueClass = value.getClass();

        Method toStringMethod;
        try {
            toStringMethod = valueClass.getMethod("toString");
        } catch (NoSuchMethodException ignored) {
            return;
        }

        if (toStringMethod.getDeclaringClass() == Object.class) {
            out.append(value);
        } else {
            String valueAsString = value.toString();

            if (valueAsString != null && !valueAsString.isEmpty()) {
                appendCharacters(valueAsString);
            } else {
                out.append(ObjectMethods.objectIdentity(value));
            }
        }
    }

    public void appendFormatted(@NonNull Object[] values) {
        String separator = "";

        for (Object value : values) {
            append(separator).appendFormatted(value);
            separator = ", ";
        }
    }
}

1	/*
2	* MIT License
3	* Copyright (c) 2006-2025 JMockit developers
4	* See LICENSE file for full license text.
5	*/
6	package mockit.internal.expectations.argumentMatching;
7
8	import edu.umd.cs.findbugs.annotations.NonNull;
9	import edu.umd.cs.findbugs.annotations.Nullable;
10
11	import java.lang.reflect.Array;
12	import java.lang.reflect.Method;
13
14	import mockit.internal.util.ObjectMethods;
15
16	public final class ArgumentMismatch {	1✔
17	@NonNull	1✔
18	private final StringBuilder out = new StringBuilder(50);
19	@Nullable
20	private String parameterType;
21
22	@Nullable
23	public String getParameterType() {
24	return parameterType;	1✔
25	}
26
27	@Override
28	public String toString() {
29	return out.toString();	1✔
30	}
31
32	@NonNull
33	public ArgumentMismatch append(char c) {
34	out.append(c);	1✔
35	return this;	1✔
36	}
37
38	@NonNull
39	public ArgumentMismatch append(int i) {
40	out.append(i);	×
41	return this;	×
42	}
43
44	@NonNull
45	public ArgumentMismatch append(double d) {
46	out.append(d);	1✔
47	return this;	1✔
48	}
49
50	@NonNull
51	public ArgumentMismatch append(@Nullable CharSequence str) {
52	out.append(str);	1✔
53	return this;	1✔
54	}
55
56	public void appendFormatted(@Nullable String parameterTypeName, @Nullable Object argumentValue,
57	@Nullable ArgumentMatcher<?> matcher) {
58	if (matcher == null) {	1✔
59	appendFormatted(argumentValue);	1✔
60	} else {
61	parameterType = parameterTypeName;	1✔
62	matcher.writeMismatchPhrase(this);	1✔
63	}
64	}	1✔
65
66	@SuppressWarnings("OverlyComplexMethod")
67	void appendFormatted(@Nullable Object value) {
68	if (value == null) {	1✔
69	out.append("null");	1✔
70	} else if (value instanceof CharSequence) {	1✔
71	appendCharacters((CharSequence) value);	1✔
72	} else if (value instanceof Character) {	1✔
73	out.append('\'');	1✔
74	appendEscapedOrPlainCharacter('\'', (Character) value);	1✔
75	out.append('\'');	1✔
76	} else if (value instanceof Byte) {	1!
77	out.append(value).append('b');	×
78	} else if (value instanceof Short) {	1!
79	out.append(value).append('s');	×
80	} else if (value instanceof Long) {	1✔
81	out.append(value).append('L');	1✔
82	} else if (value instanceof Float) {	1!
83	out.append(value).append('F');	×
84	} else if (value instanceof Number \|\| value instanceof Boolean) {	1✔
85	out.append(value);	1✔
86	} else if (value.getClass().isArray()) {	1✔
87	appendArray(value);	1✔
88	} else if (value instanceof ArgumentMatcher) {	1!
89	((ArgumentMatcher<?>) value).writeMismatchPhrase(this);	×
90	} else {
91	appendArbitraryArgument(value);	1✔
92	}
93	}	1✔
94
95	private void appendArray(@NonNull Object array) {
96	out.append('[');	1✔
97	String separator = "";	1✔
98
99	for (int i = 0, n = Array.getLength(array); i < n; i++) {	1✔
100	Object nextValue = Array.get(array, i);	1✔
101	out.append(separator);	1✔
102	appendFormatted(nextValue);	1✔
103	separator = ", ";	1✔
104	}
105
106	out.append(']');	1✔
107	}	1✔
108
109	private void appendCharacters(@NonNull CharSequence characters) {
110	out.append('"');	1✔
111
112	for (int i = 0, n = characters.length(); i < n; i++) {	1✔
113	char c = characters.charAt(i);	1✔
114	appendEscapedOrPlainCharacter('"', c);	1✔
115	}
116
117	out.append('"');	1✔
118	}	1✔
119
120	private void appendEscapedOrPlainCharacter(char quoteCharacter, char c) {
121	if (c == quoteCharacter) {	1!
122	out.append('\\').append(c);	×
123	} else {
124	switch (c) {	1!
125	case '\t':
126	out.append("\\t");	×
127	break;	×
128	case '\n':
129	out.append("\\n");	×
130	break;	×
131	case '\r':
132	out.append("\\r");	×
133	break;	×
134	default:
135	out.append(c);	1✔
136	}
137	}
138	}	1✔
139
140	private void appendArbitraryArgument(@NonNull Object value) {
141	Class<?> valueClass = value.getClass();	1✔
142
143	Method toStringMethod;
144	try {
145	toStringMethod = valueClass.getMethod("toString");	1✔
146	} catch (NoSuchMethodException ignored) {	×
147	return;	×
148	}	1✔
149
150	if (toStringMethod.getDeclaringClass() == Object.class) {	1!
151	out.append(value);	×
152	} else {
153	String valueAsString = value.toString();	1✔
154
155	if (valueAsString != null && !valueAsString.isEmpty()) {	1!
156	appendCharacters(valueAsString);	×
157	} else {
158	out.append(ObjectMethods.objectIdentity(value));	1✔
159	}
160	}
161	}	1✔
162
163	public void appendFormatted(@NonNull Object[] values) {
164	String separator = "";	1✔
165
166	for (Object value : values) {	1✔
167	append(separator).appendFormatted(value);	1✔
168	separator = ", ";	1✔
169	}
170	}	1✔
171	}

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