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

92.37

/main/src/main/java/mockit/internal/expectations/state/ExecutingTest.java

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

import static mockit.internal.util.Utilities.containsReference;

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

import java.lang.reflect.Type;
import java.util.ArrayList;
import java.util.IdentityHashMap;
import java.util.List;
import java.util.Map;

import mockit.internal.BaseInvocation;
import mockit.internal.expectations.RecordAndReplayExecution;
import mockit.internal.expectations.mocking.MockedType;
import mockit.internal.expectations.mocking.ParameterTypeRedefinitions;

public final class ExecutingTest {
    @Nullable
    private RecordAndReplayExecution currentRecordAndReplay;
    @Nullable
    private RecordAndReplayExecution recordAndReplayForLastTestMethod;

    @NonNull
    private final ThreadLocal<Boolean> shouldIgnoreMockingCallbacks;
    @NonNull
    private final ThreadLocal<BaseInvocation> proceedingInvocation;
    private boolean proceeding;

    @Nullable
    private ParameterTypeRedefinitions parameterTypeRedefinitions;

    @NonNull
    private final List<Object> regularMocks;
    @NonNull
    private final List<Object> injectableMocks;
    @NonNull
    private final Map<Object, Object> originalToCapturedInstance;
    @NonNull
    private final CascadingTypes cascadingTypes;

    public ExecutingTest() {
        shouldIgnoreMockingCallbacks = ThreadLocal.withInitial(() -> false);
        proceedingInvocation = new ThreadLocal<>();
        regularMocks = new ArrayList<>();
        injectableMocks = new ArrayList<>();
        originalToCapturedInstance = new IdentityHashMap<>(4);
        cascadingTypes = new CascadingTypes();
    }

    @NonNull
    public RecordAndReplayExecution getOrCreateRecordAndReplay() {
        if (currentRecordAndReplay == null) {
            setRecordAndReplay(new RecordAndReplayExecution());
        }

        return currentRecordAndReplay;
    }

    @Nullable
    public RecordAndReplayExecution getPreviousRecordAndReplay() {
        RecordAndReplayExecution previous = currentRecordAndReplay;
        currentRecordAndReplay = null;
        return previous;
    }

    public void setRecordAndReplay(@Nullable RecordAndReplayExecution newRecordAndReplay) {
        recordAndReplayForLastTestMethod = null;
        currentRecordAndReplay = newRecordAndReplay;
    }

    @Nullable
    public RecordAndReplayExecution getCurrentRecordAndReplay() {
        return currentRecordAndReplay;
    }

    public boolean isShouldIgnoreMockingCallbacks() {
        return shouldIgnoreMockingCallbacks.get();
    }

    public boolean setShouldIgnoreMockingCallbacks(boolean flag) {
        boolean previousFlag = shouldIgnoreMockingCallbacks.get();
        shouldIgnoreMockingCallbacks.set(flag);
        return previousFlag;
    }

    public boolean isProceedingIntoRealImplementation() {
        boolean result = proceeding;
        proceeding = false;
        return result;
    }

    public void markAsProceedingIntoRealImplementation() {
        proceeding = true;
    }

    public void markAsProceedingIntoRealImplementation(@NonNull BaseInvocation invocation) {
        BaseInvocation previousInvocation = proceedingInvocation.get();

        if (previousInvocation != null) {
            invocation.setPrevious(previousInvocation);
        }

        proceedingInvocation.set(invocation);
        proceeding = true;
    }

    public boolean shouldProceedIntoRealImplementation(@Nullable Object mock, @NonNull String classDesc) {
        BaseInvocation pendingInvocation = proceedingInvocation.get();

        // noinspection SimplifiableIfStatement
        if (pendingInvocation != null && pendingInvocation.isMethodInSuperclass(mock, classDesc)) {
            return true;
        }

        return isProceedingIntoRealImplementation();
    }

    public void clearProceedingState() {
        BaseInvocation pendingInvocation = proceedingInvocation.get();
        BaseInvocation previousInvocation = pendingInvocation.getPrevious();
        proceedingInvocation.set(previousInvocation);
    }

    @NonNull
    public RecordAndReplayExecution getRecordAndReplayForVerifications() {
        if (currentRecordAndReplay == null) {
            if (recordAndReplayForLastTestMethod != null) {
                currentRecordAndReplay = recordAndReplayForLastTestMethod;
            } else {
                // This should only happen if no expectations at all were created by the whole test, but there is one
                // (probably empty)
                // verification block.
                currentRecordAndReplay = new RecordAndReplayExecution();
            }
        }

        // noinspection LockAcquiredButNotSafelyReleased
        RecordAndReplayExecution.TEST_ONLY_PHASE_LOCK.lock();

        return currentRecordAndReplay;
    }

    @Nullable
    public ParameterTypeRedefinitions getParameterRedefinitions() {
        return parameterTypeRedefinitions;
    }

    public void setParameterRedefinitions(@NonNull ParameterTypeRedefinitions redefinitions) {
        parameterTypeRedefinitions = redefinitions;
    }

    public void clearRegularAndInjectableMocks() {
        regularMocks.clear();
        injectableMocks.clear();
    }

    void addInjectableMock(@NonNull Object mock) {
        if (!isInjectableMock(mock)) {
            injectableMocks.add(mock);
        }
    }

    public boolean isInjectableMock(@NonNull Object instance) {
        return containsReference(injectableMocks, instance);
    }

    public boolean isUnmockedInstance(@NonNull Object instance) {
        return !containsReference(regularMocks, instance) && !isInjectableMock(instance);
    }

    public static boolean isInstanceMethodWithStandardBehavior(@Nullable Object mock, @NonNull String nameAndDesc) {
        return mock != null && nameAndDesc.charAt(0) != '<'
                && ("equals(Ljava/lang/Object;)Z hashCode()I toString()Ljava/lang/String;".contains(nameAndDesc)
                        || mock instanceof Comparable<?> && nameAndDesc.startsWith("compareTo(L")
                                && nameAndDesc.endsWith(";)I"));
    }

    public void registerMock(@NonNull MockedType mockedType, @NonNull Object mock) {
        if (mockedType.injectable) {
            addInjectableMock(mock);
        } else if (!containsReference(regularMocks, mock)) {
            regularMocks.add(mock);
        }

        Type declaredType = mockedType.getDeclaredType();
        cascadingTypes.addInstance(declaredType, mock);
    }

    @NonNull
    public CascadingTypes getCascadingTypes() {
        return cascadingTypes;
    }

    public void finishExecution() {
        recordAndReplayForLastTestMethod = currentRecordAndReplay;
        currentRecordAndReplay = null;

        if (parameterTypeRedefinitions != null) {
            parameterTypeRedefinitions.cleanUp();
            parameterTypeRedefinitions = null;
        }

        cascadingTypes.clearNonSharedCascadingTypes();
    }

    public void addCapturedInstanceForInjectableMock(@Nullable Object originalInstance,
            @NonNull Object capturedInstance) {
        injectableMocks.add(capturedInstance);
        addCapturedInstance(originalInstance, capturedInstance);
    }

    public void addCapturedInstance(@Nullable Object originalInstance, @NonNull Object capturedInstance) {
        originalToCapturedInstance.put(capturedInstance, originalInstance);
    }
}

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.state;
7
8	import static mockit.internal.util.Utilities.containsReference;
9
10	import edu.umd.cs.findbugs.annotations.NonNull;
11	import edu.umd.cs.findbugs.annotations.Nullable;
12
13	import java.lang.reflect.Type;
14	import java.util.ArrayList;
15	import java.util.IdentityHashMap;
16	import java.util.List;
17	import java.util.Map;
18
19	import mockit.internal.BaseInvocation;
20	import mockit.internal.expectations.RecordAndReplayExecution;
21	import mockit.internal.expectations.mocking.MockedType;
22	import mockit.internal.expectations.mocking.ParameterTypeRedefinitions;
23
24	public final class ExecutingTest {
25	@Nullable
26	private RecordAndReplayExecution currentRecordAndReplay;
27	@Nullable
28	private RecordAndReplayExecution recordAndReplayForLastTestMethod;
29
30	@NonNull
31	private final ThreadLocal<Boolean> shouldIgnoreMockingCallbacks;
32	@NonNull
33	private final ThreadLocal<BaseInvocation> proceedingInvocation;
34	private boolean proceeding;
35
36	@Nullable
37	private ParameterTypeRedefinitions parameterTypeRedefinitions;
38
39	@NonNull
40	private final List<Object> regularMocks;
41	@NonNull
42	private final List<Object> injectableMocks;
43	@NonNull
44	private final Map<Object, Object> originalToCapturedInstance;
45	@NonNull
46	private final CascadingTypes cascadingTypes;
47
48	public ExecutingTest() {	1✔
49	shouldIgnoreMockingCallbacks = ThreadLocal.withInitial(() -> false);	1✔
50	proceedingInvocation = new ThreadLocal<>();	1✔
51	regularMocks = new ArrayList<>();	1✔
52	injectableMocks = new ArrayList<>();	1✔
53	originalToCapturedInstance = new IdentityHashMap<>(4);	1✔
54	cascadingTypes = new CascadingTypes();	1✔
55	}	1✔
56
57	@NonNull
58	public RecordAndReplayExecution getOrCreateRecordAndReplay() {
59	if (currentRecordAndReplay == null) {	1✔
60	setRecordAndReplay(new RecordAndReplayExecution());	1✔
61	}
62
63	return currentRecordAndReplay;	1✔
64	}
65
66	@Nullable
67	public RecordAndReplayExecution getPreviousRecordAndReplay() {
68	RecordAndReplayExecution previous = currentRecordAndReplay;	1✔
69	currentRecordAndReplay = null;	1✔
70	return previous;	1✔
71	}
72
73	public void setRecordAndReplay(@Nullable RecordAndReplayExecution newRecordAndReplay) {
74	recordAndReplayForLastTestMethod = null;	1✔
75	currentRecordAndReplay = newRecordAndReplay;	1✔
76	}	1✔
77
78	@Nullable
79	public RecordAndReplayExecution getCurrentRecordAndReplay() {
80	return currentRecordAndReplay;	1✔
81	}
82
83	public boolean isShouldIgnoreMockingCallbacks() {
84	return shouldIgnoreMockingCallbacks.get();	1✔
85	}
86
87	public boolean setShouldIgnoreMockingCallbacks(boolean flag) {
88	boolean previousFlag = shouldIgnoreMockingCallbacks.get();	1✔
89	shouldIgnoreMockingCallbacks.set(flag);	1✔
90	return previousFlag;	1✔
91	}
92
93	public boolean isProceedingIntoRealImplementation() {
94	boolean result = proceeding;	1✔
95	proceeding = false;	1✔
96	return result;	1✔
97	}
98
99	public void markAsProceedingIntoRealImplementation() {
100	proceeding = true;	1✔
101	}	1✔
102
103	public void markAsProceedingIntoRealImplementation(@NonNull BaseInvocation invocation) {
104	BaseInvocation previousInvocation = proceedingInvocation.get();	1✔
105
106	if (previousInvocation != null) {	1!
107	invocation.setPrevious(previousInvocation);	×
108	}
109
110	proceedingInvocation.set(invocation);	1✔
111	proceeding = true;	1✔
112	}	1✔
113
114	public boolean shouldProceedIntoRealImplementation(@Nullable Object mock, @NonNull String classDesc) {
115	BaseInvocation pendingInvocation = proceedingInvocation.get();	1✔
116
117	// noinspection SimplifiableIfStatement
118	if (pendingInvocation != null && pendingInvocation.isMethodInSuperclass(mock, classDesc)) {	1✔
119	return true;	1✔
120	}
121
122	return isProceedingIntoRealImplementation();	1✔
123	}
124
125	public void clearProceedingState() {
126	BaseInvocation pendingInvocation = proceedingInvocation.get();	1✔
127	BaseInvocation previousInvocation = pendingInvocation.getPrevious();	1✔
128	proceedingInvocation.set(previousInvocation);	1✔
129	}	1✔
130
131	@NonNull
132	public RecordAndReplayExecution getRecordAndReplayForVerifications() {
133	if (currentRecordAndReplay == null) {	1✔
134	if (recordAndReplayForLastTestMethod != null) {	1✔
135	currentRecordAndReplay = recordAndReplayForLastTestMethod;	1✔
136	} else {
137	// This should only happen if no expectations at all were created by the whole test, but there is one
138	// (probably empty)
139	// verification block.
140	currentRecordAndReplay = new RecordAndReplayExecution();	1✔
141	}
142	}
143
144	// noinspection LockAcquiredButNotSafelyReleased
145	RecordAndReplayExecution.TEST_ONLY_PHASE_LOCK.lock();	1✔
146
147	return currentRecordAndReplay;	1✔
148	}
149
150	@Nullable
151	public ParameterTypeRedefinitions getParameterRedefinitions() {
152	return parameterTypeRedefinitions;	1✔
153	}
154
155	public void setParameterRedefinitions(@NonNull ParameterTypeRedefinitions redefinitions) {
156	parameterTypeRedefinitions = redefinitions;	1✔
157	}	1✔
158
159	public void clearRegularAndInjectableMocks() {
160	regularMocks.clear();	1✔
161	injectableMocks.clear();	1✔
162	}	1✔
163
164	void addInjectableMock(@NonNull Object mock) {
165	if (!isInjectableMock(mock)) {	1!
166	injectableMocks.add(mock);	1✔
167	}
168	}	1✔
169
170	public boolean isInjectableMock(@NonNull Object instance) {
171	return containsReference(injectableMocks, instance);	1✔
172	}
173
174	public boolean isUnmockedInstance(@NonNull Object instance) {
175	return !containsReference(regularMocks, instance) && !isInjectableMock(instance);	1!
176	}
177
178	public static boolean isInstanceMethodWithStandardBehavior(@Nullable Object mock, @NonNull String nameAndDesc) {
179	return mock != null && nameAndDesc.charAt(0) != '<'	1✔
180	&& ("equals(Ljava/lang/Object;)Z hashCode()I toString()Ljava/lang/String;".contains(nameAndDesc)	1✔
181	\|\| mock instanceof Comparable<?> && nameAndDesc.startsWith("compareTo(L")	1✔
182	&& nameAndDesc.endsWith(";)I"));	1!
183	}
184
185	public void registerMock(@NonNull MockedType mockedType, @NonNull Object mock) {
186	if (mockedType.injectable) {	1✔
187	addInjectableMock(mock);	1✔
188	} else if (!containsReference(regularMocks, mock)) {	1!
189	regularMocks.add(mock);	1✔
190	}
191
192	Type declaredType = mockedType.getDeclaredType();	1✔
193	cascadingTypes.addInstance(declaredType, mock);	1✔
194	}	1✔
195
196	@NonNull
197	public CascadingTypes getCascadingTypes() {
198	return cascadingTypes;	1✔
199	}
200
201	public void finishExecution() {
202	recordAndReplayForLastTestMethod = currentRecordAndReplay;	1✔
203	currentRecordAndReplay = null;	1✔
204
205	if (parameterTypeRedefinitions != null) {	1✔
206	parameterTypeRedefinitions.cleanUp();	1✔
207	parameterTypeRedefinitions = null;	1✔
208	}
209
210	cascadingTypes.clearNonSharedCascadingTypes();	1✔
211	}	1✔
212
213	public void addCapturedInstanceForInjectableMock(@Nullable Object originalInstance,
214	@NonNull Object capturedInstance) {
215	injectableMocks.add(capturedInstance);	×
216	addCapturedInstance(originalInstance, capturedInstance);	×
217	}	×
218
219	public void addCapturedInstance(@Nullable Object originalInstance, @NonNull Object capturedInstance) {
220	originalToCapturedInstance.put(capturedInstance, originalInstance);	1✔
221	}	1✔
222	}

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