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

95.77

/main/src/main/java/mockit/internal/expectations/invocation/ArgumentValuesAndMatchers.java

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

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

import java.util.List;
import java.util.Map;

import mockit.internal.expectations.argumentMatching.AlwaysTrueMatcher;
import mockit.internal.expectations.argumentMatching.ArgumentMatcher;
import mockit.internal.expectations.argumentMatching.ArgumentMismatch;
import mockit.internal.expectations.argumentMatching.EqualityMatcher;
import mockit.internal.expectations.argumentMatching.HamcrestAdapter;
import mockit.internal.expectations.argumentMatching.ReflectiveMatcher;

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

abstract class ArgumentValuesAndMatchers {
    @NonNull
    final InvocationArguments signature;
    @NonNull
    Object[] values;
    @Nullable
    List<ArgumentMatcher<?>> matchers;

    ArgumentValuesAndMatchers(@NonNull InvocationArguments signature, @NonNull Object[] values) {
        this.signature = signature;
        this.values = values;
    }

    final void setValuesWithNoMatchers(@NonNull Object[] argsToVerify) {
        setValuesAndMatchers(argsToVerify, null);
    }

    @NonNull
    final Object[] prepareForVerification(@NonNull Object[] argsToVerify,
            @Nullable List<ArgumentMatcher<?>> matchersToUse) {
        Object[] replayArgs = values;
        setValuesAndMatchers(argsToVerify, matchersToUse);
        return replayArgs;
    }

    final void setValuesAndMatchers(@NonNull Object[] argsToVerify, @Nullable List<ArgumentMatcher<?>> matchersToUse) {
        values = argsToVerify;
        matchers = matchersToUse;
    }

    @Nullable
    final ArgumentMatcher<?> getArgumentMatcher(@NonNegative int parameterIndex) {
        if (matchers == null) {
            return null;
        }

        ArgumentMatcher<?> matcher = parameterIndex < matchers.size() ? matchers.get(parameterIndex) : null;

        if (matcher == null && parameterIndex < values.length && values[parameterIndex] == null) {
            matcher = AlwaysTrueMatcher.ANY_VALUE;
        }

        return matcher;
    }

    abstract boolean isMatch(@NonNull Object[] replayArgs, @NonNull Map<Object, Object> instanceMap);

    static boolean areEqual(@NonNull Object[] expectedValues, @NonNull Object[] actualValues, @NonNegative int count,
            @NonNull Map<Object, Object> instanceMap) {
        for (int i = 0; i < count; i++) {
            if (isNotEqual(expectedValues[i], actualValues[i], instanceMap)) {
                return false;
            }
        }

        return true;
    }

    private static boolean isNotEqual(@Nullable Object expected, @Nullable Object actual,
            @NonNull Map<Object, Object> instanceMap) {
        return actual == null == (expected != null) || actual != null && actual != expected
                && expected != instanceMap.get(actual) && !EqualityMatcher.areEqualWhenNonNull(actual, expected);
    }

    abstract boolean hasEquivalentMatchers(@NonNull ArgumentValuesAndMatchers other);

    private static boolean equivalentMatches(@NonNull ArgumentMatcher<?> matcher1, @Nullable Object arg1,
            @NonNull ArgumentMatcher<?> matcher2, @Nullable Object arg2) {
        boolean matcher1MatchesArg2 = matcher1.matches(arg2);
        boolean matcher2MatchesArg1 = matcher2.matches(arg1);

        if (arg1 != null && arg2 != null && matcher1MatchesArg2 && matcher2MatchesArg1) {
            return true;
        }

        if (arg1 == arg2 && matcher1MatchesArg2 == matcher2MatchesArg1) { // both matchers fail
            ArgumentMismatch desc1 = new ArgumentMismatch();
            matcher1.writeMismatchPhrase(desc1);
            ArgumentMismatch desc2 = new ArgumentMismatch();
            matcher2.writeMismatchPhrase(desc2);
            return desc1.toString().equals(desc2.toString());
        }

        return false;
    }

    @SuppressWarnings("unchecked")
    final <M1 extends ArgumentMatcher<M1>, M2 extends ArgumentMatcher<M2>> int indexOfFirstValueAfterEquivalentMatchers(
            @NonNull ArgumentValuesAndMatchers other) {
        List<ArgumentMatcher<?>> otherMatchers = other.matchers;

        if (hasDifferentAmountOfMatchers(otherMatchers)) {
            return -1;
        }

        // noinspection ConstantConditions
        int m = matchers.size();
        int i;

        for (i = 0; i < m; i++) {
            M1 matcher1 = (M1) matchers.get(i);
            M2 matcher2 = (M2) otherMatchers.get(i);

            if (matcher1 == null || matcher2 == null) {
                if (!EqualityMatcher.areEqual(values[i], other.values[i])) {
                    return -1;
                }
            } else if (matcher1 != matcher2 && (matcher1.getClass() != matcher2.getClass()
                    || !matcher1.same((M1) matcher2) && areNonEquivalentMatches(other, matcher1, matcher2, i))) {
                return -1;
            }
        }

        return i;
    }

    private boolean hasDifferentAmountOfMatchers(@Nullable List<ArgumentMatcher<?>> otherMatchers) {
        return otherMatchers == null || matchers == null || otherMatchers.size() != matchers.size();
    }

    private boolean areNonEquivalentMatches(@NonNull ArgumentValuesAndMatchers other,
            @NonNull ArgumentMatcher<?> matcher1, @NonNull ArgumentMatcher<?> matcher2, @NonNegative int matcherIndex) {
        Class<?> matcherClass = matcher1.getClass();
        return matcherClass == ReflectiveMatcher.class || matcherClass == HamcrestAdapter.class
                || !equivalentMatches(matcher1, values[matcherIndex], matcher2, other.values[matcherIndex]);
    }

    @NonNull
    final String toString(@NonNull List<String> parameterTypes) {
        ArgumentMismatch desc = new ArgumentMismatch();
        int parameterCount = values.length;

        if (parameterCount > 0) {
            if (matchers == null) {
                desc.appendFormatted(values);
            } else {
                String sep = "";

                for (int i = 0; i < parameterCount; i++) {
                    ArgumentMatcher<?> matcher = getArgumentMatcher(i);
                    String parameterType = parameterTypes.get(i);
                    desc.append(sep).appendFormatted(parameterType, values[i], matcher);
                    sep = ", ";
                }
            }

            desc.append(')');
        }

        return desc.toString();
    }
}

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.invocation;
7
8	import edu.umd.cs.findbugs.annotations.NonNull;
9	import edu.umd.cs.findbugs.annotations.Nullable;
10
11	import java.util.List;
12	import java.util.Map;
13
14	import mockit.internal.expectations.argumentMatching.AlwaysTrueMatcher;
15	import mockit.internal.expectations.argumentMatching.ArgumentMatcher;
16	import mockit.internal.expectations.argumentMatching.ArgumentMismatch;
17	import mockit.internal.expectations.argumentMatching.EqualityMatcher;
18	import mockit.internal.expectations.argumentMatching.HamcrestAdapter;
19	import mockit.internal.expectations.argumentMatching.ReflectiveMatcher;
20
21	import org.checkerframework.checker.index.qual.NonNegative;
22
23	abstract class ArgumentValuesAndMatchers {
24	@NonNull
25	final InvocationArguments signature;
26	@NonNull
27	Object[] values;
28	@Nullable
29	List<ArgumentMatcher<?>> matchers;
30
31	ArgumentValuesAndMatchers(@NonNull InvocationArguments signature, @NonNull Object[] values) {	1✔
32	this.signature = signature;	1✔
33	this.values = values;	1✔
34	}	1✔
35
36	final void setValuesWithNoMatchers(@NonNull Object[] argsToVerify) {
37	setValuesAndMatchers(argsToVerify, null);	1✔
38	}	1✔
39
40	@NonNull
41	final Object[] prepareForVerification(@NonNull Object[] argsToVerify,
42	@Nullable List<ArgumentMatcher<?>> matchersToUse) {
43	Object[] replayArgs = values;	1✔
44	setValuesAndMatchers(argsToVerify, matchersToUse);	1✔
45	return replayArgs;	1✔
46	}
47
48	final void setValuesAndMatchers(@NonNull Object[] argsToVerify, @Nullable List<ArgumentMatcher<?>> matchersToUse) {
49	values = argsToVerify;	1✔
50	matchers = matchersToUse;	1✔
51	}	1✔
52
53	@Nullable
54	final ArgumentMatcher<?> getArgumentMatcher(@NonNegative int parameterIndex) {
55	if (matchers == null) {	1!
56	return null;	×
57	}
58
59	ArgumentMatcher<?> matcher = parameterIndex < matchers.size() ? matchers.get(parameterIndex) : null;	1✔
60
61	if (matcher == null && parameterIndex < values.length && values[parameterIndex] == null) {	1✔
62	matcher = AlwaysTrueMatcher.ANY_VALUE;	1✔
63	}
64
65	return matcher;	1✔
66	}
67
68	abstract boolean isMatch(@NonNull Object[] replayArgs, @NonNull Map<Object, Object> instanceMap);
69
70	static boolean areEqual(@NonNull Object[] expectedValues, @NonNull Object[] actualValues, @NonNegative int count,
71	@NonNull Map<Object, Object> instanceMap) {
72	for (int i = 0; i < count; i++) {	1✔
73	if (isNotEqual(expectedValues[i], actualValues[i], instanceMap)) {	1✔
74	return false;	1✔
75	}
76	}
77
78	return true;	1✔
79	}
80
81	private static boolean isNotEqual(@Nullable Object expected, @Nullable Object actual,
82	@NonNull Map<Object, Object> instanceMap) {
83	return actual == null == (expected != null) \|\| actual != null && actual != expected	1✔
84	&& expected != instanceMap.get(actual) && !EqualityMatcher.areEqualWhenNonNull(actual, expected);	1✔
85	}
86
87	abstract boolean hasEquivalentMatchers(@NonNull ArgumentValuesAndMatchers other);
88
89	private static boolean equivalentMatches(@NonNull ArgumentMatcher<?> matcher1, @Nullable Object arg1,
90	@NonNull ArgumentMatcher<?> matcher2, @Nullable Object arg2) {
91	boolean matcher1MatchesArg2 = matcher1.matches(arg2);	1✔
92	boolean matcher2MatchesArg1 = matcher2.matches(arg1);	1✔
93
94	if (arg1 != null && arg2 != null && matcher1MatchesArg2 && matcher2MatchesArg1) {	1!
95	return true;	1✔
96	}
97
98	if (arg1 == arg2 && matcher1MatchesArg2 == matcher2MatchesArg1) { // both matchers fail	1!
99	ArgumentMismatch desc1 = new ArgumentMismatch();	1✔
100	matcher1.writeMismatchPhrase(desc1);	1✔
101	ArgumentMismatch desc2 = new ArgumentMismatch();	1✔
102	matcher2.writeMismatchPhrase(desc2);	1✔
103	return desc1.toString().equals(desc2.toString());	1✔
104	}
105
106	return false;	1✔
107	}
108
109	@SuppressWarnings("unchecked")
110	final <M1 extends ArgumentMatcher<M1>, M2 extends ArgumentMatcher<M2>> int indexOfFirstValueAfterEquivalentMatchers(
111	@NonNull ArgumentValuesAndMatchers other) {
112	List<ArgumentMatcher<?>> otherMatchers = other.matchers;	1✔
113
114	if (hasDifferentAmountOfMatchers(otherMatchers)) {	1✔
115	return -1;	1✔
116	}
117
118	// noinspection ConstantConditions
119	int m = matchers.size();	1✔
120	int i;
121
122	for (i = 0; i < m; i++) {	1✔
123	M1 matcher1 = (M1) matchers.get(i);	1✔
124	M2 matcher2 = (M2) otherMatchers.get(i);	1✔
125
126	if (matcher1 == null \|\| matcher2 == null) {	1✔
127	if (!EqualityMatcher.areEqual(values[i], other.values[i])) {	1✔
128	return -1;	1✔
129	}
130	} else if (matcher1 != matcher2 && (matcher1.getClass() != matcher2.getClass()	1✔
131	\|\| !matcher1.same((M1) matcher2) && areNonEquivalentMatches(other, matcher1, matcher2, i))) {	1✔
132	return -1;	1✔
133	}
134	}
135
136	return i;	1✔
137	}
138
139	private boolean hasDifferentAmountOfMatchers(@Nullable List<ArgumentMatcher<?>> otherMatchers) {
140	return otherMatchers == null \|\| matchers == null \|\| otherMatchers.size() != matchers.size();	1!
141	}
142
143	private boolean areNonEquivalentMatches(@NonNull ArgumentValuesAndMatchers other,
144	@NonNull ArgumentMatcher<?> matcher1, @NonNull ArgumentMatcher<?> matcher2, @NonNegative int matcherIndex) {
145	Class<?> matcherClass = matcher1.getClass();	1✔
146	return matcherClass == ReflectiveMatcher.class \|\| matcherClass == HamcrestAdapter.class	1!
147	\|\| !equivalentMatches(matcher1, values[matcherIndex], matcher2, other.values[matcherIndex]);	1✔
148	}
149
150	@NonNull
151	final String toString(@NonNull List<String> parameterTypes) {
152	ArgumentMismatch desc = new ArgumentMismatch();	1✔
153	int parameterCount = values.length;	1✔
154
155	if (parameterCount > 0) {	1✔
156	if (matchers == null) {	1✔
157	desc.appendFormatted(values);	1✔
158	} else {
159	String sep = "";	1✔
160
161	for (int i = 0; i < parameterCount; i++) {	1✔
162	ArgumentMatcher<?> matcher = getArgumentMatcher(i);	1✔
163	String parameterType = parameterTypes.get(i);	1✔
164	desc.append(sep).appendFormatted(parameterType, values[i], matcher);	1✔
165	sep = ", ";	1✔
166	}
167	}
168
169	desc.append(')');	1✔
170	}
171
172	return desc.toString();	1✔
173	}
174	}

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