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.91

/main/src/main/java/mockit/internal/faking/FakeClasses.java

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

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

import java.lang.reflect.Field;
import java.lang.reflect.InvocationTargetException;
import java.lang.reflect.Method;
import java.util.IdentityHashMap;
import java.util.Map;
import java.util.Map.Entry;

import mockit.MockUp;
import mockit.internal.util.ClassLoad;

public final class FakeClasses {
    private static final Field INVOKED_INSTANCE_FIELD;
    private static final Method ON_TEAR_DOWN_METHOD;

    static {
        try {
            INVOKED_INSTANCE_FIELD = MockUp.class.getDeclaredField("invokedInstance");
            INVOKED_INSTANCE_FIELD.setAccessible(true);

            ON_TEAR_DOWN_METHOD = MockUp.class.getDeclaredMethod("onTearDown");
            ON_TEAR_DOWN_METHOD.setAccessible(true);
        } catch (NoSuchFieldException | NoSuchMethodException e) {
            throw new RuntimeException(e);
        }
    }

    private static void notifyOfTearDown(@NonNull MockUp<?> mockUp) {
        try {
            ON_TEAR_DOWN_METHOD.invoke(mockUp);
        } catch (IllegalAccessException ignore) {
        } catch (InvocationTargetException e) {
            e.getCause().printStackTrace();
        }
    }

    public static final class MockUpInstances {
        @NonNull
        public final MockUp<?> initialMockUp;
        boolean hasMockupsForSingleInstances;

        MockUpInstances(@NonNull MockUp<?> initialMockUp) {
            this.initialMockUp = initialMockUp;
            hasMockupsForSingleInstances = false;
        }

        public boolean hasMockUpsForSingleInstances() {
            return hasMockupsForSingleInstances;
        }

        void notifyMockUpOfTearDown() {
            notifyOfTearDown(initialMockUp);
        }
    }

    @NonNull
    private final Map<String, MockUp<?>> startupMocks;
    @NonNull
    private final Map<Class<?>, MockUpInstances> mockupClassesToMockupInstances;
    @NonNull
    private final Map<Object, MockUp<?>> mockedToMockupInstances;
    @NonNull
    public final FakeStates fakeStates;

    public FakeClasses() {
        startupMocks = new IdentityHashMap<>(8);
        mockupClassesToMockupInstances = new IdentityHashMap<>();
        mockedToMockupInstances = new IdentityHashMap<>();
        fakeStates = new FakeStates();
    }

    public void addFake(@NonNull String mockClassDesc, @NonNull MockUp<?> mockUp) {
        startupMocks.put(mockClassDesc, mockUp);
    }

    public void addFake(@NonNull MockUp<?> mockUp) {
        Class<?> mockUpClass = mockUp.getClass();
        MockUpInstances newData = new MockUpInstances(mockUp);
        mockupClassesToMockupInstances.put(mockUpClass, newData);
    }

    public void addFake(@NonNull MockUp<?> mockUp, @NonNull Object mockedInstance) {
        MockUp<?> previousMockup = mockedToMockupInstances.put(mockedInstance, mockUp);
        assert previousMockup == null;

        MockUpInstances mockUpInstances = mockupClassesToMockupInstances.get(mockUp.getClass());
        mockUpInstances.hasMockupsForSingleInstances = true;
    }

    @Nullable
    public MockUp<?> getFake(@NonNull String mockUpClassDesc, @Nullable Object mockedInstance) {
        if (mockedInstance != null) {
            MockUp<?> mockUpForSingleInstance = mockedToMockupInstances.get(mockedInstance);

            if (mockUpForSingleInstance != null) {
                return mockUpForSingleInstance;
            }
        }

        MockUp<?> startupMock = startupMocks.get(mockUpClassDesc);

        if (startupMock != null) {
            return startupMock;
        }

        Class<?> mockUpClass = ClassLoad.loadByInternalName(mockUpClassDesc);
        MockUpInstances mockUpInstances = mockupClassesToMockupInstances.get(mockUpClass);
        Object invokedInstance = mockedInstance;

        if (mockedInstance == null) {
            invokedInstance = Void.class;
        } else if (mockUpInstances.hasMockUpsForSingleInstances()) {
            return null;
        }

        try {
            INVOKED_INSTANCE_FIELD.set(mockUpInstances.initialMockUp, invokedInstance);
        } catch (IllegalAccessException ignore) {
        }

        return mockUpInstances.initialMockUp;
    }

    @Nullable
    public MockUpInstances findPreviouslyAppliedMockUps(@NonNull MockUp<?> newMockUp) {
        Class<?> mockUpClass = newMockUp.getClass();
        MockUpInstances mockUpInstances = mockupClassesToMockupInstances.get(mockUpClass);

        if (mockUpInstances != null && mockUpInstances.hasMockupsForSingleInstances) {
            fakeStates.copyFakeStates(mockUpInstances.initialMockUp, newMockUp);
        }

        return mockUpInstances;
    }

    private void discardMockupInstances(@NonNull Map<Object, MockUp<?>> previousMockInstances) {
        if (!previousMockInstances.isEmpty()) {
            mockedToMockupInstances.entrySet().retainAll(previousMockInstances.entrySet());
        } else if (!mockedToMockupInstances.isEmpty()) {
            mockedToMockupInstances.clear();
        }
    }

    private void discardMockupInstancesExceptPreviousOnes(@NonNull Map<Class<?>, Boolean> previousMockupClasses) {
        updatePreviousMockups(previousMockupClasses);

        for (Entry<Class<?>, MockUpInstances> mockupClassAndInstances : mockupClassesToMockupInstances.entrySet()) {
            Class<?> mockupClass = mockupClassAndInstances.getKey();

            if (!previousMockupClasses.containsKey(mockupClass)) {
                MockUpInstances mockUpInstances = mockupClassAndInstances.getValue();
                mockUpInstances.notifyMockUpOfTearDown();
            }
        }

        mockupClassesToMockupInstances.keySet().retainAll(previousMockupClasses.keySet());
    }

    private void updatePreviousMockups(@NonNull Map<Class<?>, Boolean> previousMockupClasses) {
        for (Entry<Class<?>, Boolean> mockupClassAndData : previousMockupClasses.entrySet()) {
            Class<?> mockupClass = mockupClassAndData.getKey();
            MockUpInstances mockUpData = mockupClassesToMockupInstances.get(mockupClass);
            mockUpData.hasMockupsForSingleInstances = mockupClassAndData.getValue();
        }
    }

    private void discardAllMockupInstances() {
        if (!mockupClassesToMockupInstances.isEmpty()) {
            for (MockUpInstances mockUpInstances : mockupClassesToMockupInstances.values()) {
                mockUpInstances.notifyMockUpOfTearDown();
            }

            mockupClassesToMockupInstances.clear();
        }
    }

    public void discardStartupFakes() {
        for (MockUp<?> startupMockup : startupMocks.values()) {
            notifyOfTearDown(startupMockup);
        }
    }

    public final class SavePoint {
        @NonNull
        private final Map<Object, MockUp<?>> previousMockInstances;
        @NonNull
        private final Map<Class<?>, Boolean> previousMockupClasses;

        public SavePoint() {
            previousMockInstances = new IdentityHashMap<>(mockedToMockupInstances);
            previousMockupClasses = new IdentityHashMap<>();

            for (Entry<Class<?>, MockUpInstances> mockUpClassAndData : mockupClassesToMockupInstances.entrySet()) {
                Class<?> mockUpClass = mockUpClassAndData.getKey();
                MockUpInstances mockUpData = mockUpClassAndData.getValue();
                previousMockupClasses.put(mockUpClass, mockUpData.hasMockupsForSingleInstances);
            }
        }

        public void rollback() {
            discardMockupInstances(previousMockInstances);

            if (!previousMockupClasses.isEmpty()) {
                discardMockupInstancesExceptPreviousOnes(previousMockupClasses);
            } else {
                discardAllMockupInstances();
            }
        }
    }
}

1	/*
2	* MIT License
3	* Copyright (c) 2006-2025 JMockit developers
4	* See LICENSE file for full license text.
5	*/
6	package mockit.internal.faking;
7
8	import edu.umd.cs.findbugs.annotations.NonNull;
9	import edu.umd.cs.findbugs.annotations.Nullable;
10
11	import java.lang.reflect.Field;
12	import java.lang.reflect.InvocationTargetException;
13	import java.lang.reflect.Method;
14	import java.util.IdentityHashMap;
15	import java.util.Map;
16	import java.util.Map.Entry;
17
18	import mockit.MockUp;
19	import mockit.internal.util.ClassLoad;
20
21	public final class FakeClasses {
22	private static final Field INVOKED_INSTANCE_FIELD;
23	private static final Method ON_TEAR_DOWN_METHOD;
24
25	static {
26	try {
27	INVOKED_INSTANCE_FIELD = MockUp.class.getDeclaredField("invokedInstance");	1✔
28	INVOKED_INSTANCE_FIELD.setAccessible(true);	1✔
29
30	ON_TEAR_DOWN_METHOD = MockUp.class.getDeclaredMethod("onTearDown");	1✔
31	ON_TEAR_DOWN_METHOD.setAccessible(true);	1✔
32	} catch (NoSuchFieldException \| NoSuchMethodException e) {	×
33	throw new RuntimeException(e);	×
34	}	1✔
35	}	1✔
36
37	private static void notifyOfTearDown(@NonNull MockUp<?> mockUp) {
38	try {
39	ON_TEAR_DOWN_METHOD.invoke(mockUp);	1✔
40	} catch (IllegalAccessException ignore) {	×
41	} catch (InvocationTargetException e) {	×
42	e.getCause().printStackTrace();	×
43	}	1✔
44	}	1✔
45
46	public static final class MockUpInstances {
47	@NonNull
48	public final MockUp<?> initialMockUp;
49	boolean hasMockupsForSingleInstances;
50
51	MockUpInstances(@NonNull MockUp<?> initialMockUp) {	1✔
52	this.initialMockUp = initialMockUp;	1✔
53	hasMockupsForSingleInstances = false;	1✔
54	}	1✔
55
56	public boolean hasMockUpsForSingleInstances() {
57	return hasMockupsForSingleInstances;	1✔
58	}
59
60	void notifyMockUpOfTearDown() {
61	notifyOfTearDown(initialMockUp);	1✔
62	}	1✔
63	}
64
65	@NonNull
66	private final Map<String, MockUp<?>> startupMocks;
67	@NonNull
68	private final Map<Class<?>, MockUpInstances> mockupClassesToMockupInstances;
69	@NonNull
70	private final Map<Object, MockUp<?>> mockedToMockupInstances;
71	@NonNull
72	public final FakeStates fakeStates;
73
74	public FakeClasses() {	1✔
75	startupMocks = new IdentityHashMap<>(8);	1✔
76	mockupClassesToMockupInstances = new IdentityHashMap<>();	1✔
77	mockedToMockupInstances = new IdentityHashMap<>();	1✔
78	fakeStates = new FakeStates();	1✔
79	}	1✔
80
81	public void addFake(@NonNull String mockClassDesc, @NonNull MockUp<?> mockUp) {
82	startupMocks.put(mockClassDesc, mockUp);	1✔
83	}	1✔
84
85	public void addFake(@NonNull MockUp<?> mockUp) {
86	Class<?> mockUpClass = mockUp.getClass();	1✔
87	MockUpInstances newData = new MockUpInstances(mockUp);	1✔
88	mockupClassesToMockupInstances.put(mockUpClass, newData);	1✔
89	}	1✔
90
91	public void addFake(@NonNull MockUp<?> mockUp, @NonNull Object mockedInstance) {
92	MockUp<?> previousMockup = mockedToMockupInstances.put(mockedInstance, mockUp);	1✔
93	assert previousMockup == null;	1!
94
95	MockUpInstances mockUpInstances = mockupClassesToMockupInstances.get(mockUp.getClass());	1✔
96	mockUpInstances.hasMockupsForSingleInstances = true;	1✔
97	}	1✔
98
99	@Nullable
100	public MockUp<?> getFake(@NonNull String mockUpClassDesc, @Nullable Object mockedInstance) {
101	if (mockedInstance != null) {	1✔
102	MockUp<?> mockUpForSingleInstance = mockedToMockupInstances.get(mockedInstance);	1✔
103
104	if (mockUpForSingleInstance != null) {	1✔
105	return mockUpForSingleInstance;	1✔
106	}
107	}
108
109	MockUp<?> startupMock = startupMocks.get(mockUpClassDesc);	1✔
110
111	if (startupMock != null) {	1✔
112	return startupMock;	1✔
113	}
114
115	Class<?> mockUpClass = ClassLoad.loadByInternalName(mockUpClassDesc);	1✔
116	MockUpInstances mockUpInstances = mockupClassesToMockupInstances.get(mockUpClass);	1✔
117	Object invokedInstance = mockedInstance;	1✔
118
119	if (mockedInstance == null) {	1✔
120	invokedInstance = Void.class;	1✔
121	} else if (mockUpInstances.hasMockUpsForSingleInstances()) {	1✔
122	return null;	1✔
123	}
124
125	try {
126	INVOKED_INSTANCE_FIELD.set(mockUpInstances.initialMockUp, invokedInstance);	1✔
127	} catch (IllegalAccessException ignore) {	×
128	}	1✔
129
130	return mockUpInstances.initialMockUp;	1✔
131	}
132
133	@Nullable
134	public MockUpInstances findPreviouslyAppliedMockUps(@NonNull MockUp<?> newMockUp) {
135	Class<?> mockUpClass = newMockUp.getClass();	1✔
136	MockUpInstances mockUpInstances = mockupClassesToMockupInstances.get(mockUpClass);	1✔
137
138	if (mockUpInstances != null && mockUpInstances.hasMockupsForSingleInstances) {	1✔
139	fakeStates.copyFakeStates(mockUpInstances.initialMockUp, newMockUp);	1✔
140	}
141
142	return mockUpInstances;	1✔
143	}
144
145	private void discardMockupInstances(@NonNull Map<Object, MockUp<?>> previousMockInstances) {
146	if (!previousMockInstances.isEmpty()) {	1!
147	mockedToMockupInstances.entrySet().retainAll(previousMockInstances.entrySet());	×
148	} else if (!mockedToMockupInstances.isEmpty()) {	1✔
149	mockedToMockupInstances.clear();	1✔
150	}
151	}	1✔
152
153	private void discardMockupInstancesExceptPreviousOnes(@NonNull Map<Class<?>, Boolean> previousMockupClasses) {
154	updatePreviousMockups(previousMockupClasses);	1✔
155
156	for (Entry<Class<?>, MockUpInstances> mockupClassAndInstances : mockupClassesToMockupInstances.entrySet()) {	1✔
157	Class<?> mockupClass = mockupClassAndInstances.getKey();	1✔
158
159	if (!previousMockupClasses.containsKey(mockupClass)) {	1✔
160	MockUpInstances mockUpInstances = mockupClassAndInstances.getValue();	1✔
161	mockUpInstances.notifyMockUpOfTearDown();	1✔
162	}
163	}	1✔
164
165	mockupClassesToMockupInstances.keySet().retainAll(previousMockupClasses.keySet());	1✔
166	}	1✔
167
168	private void updatePreviousMockups(@NonNull Map<Class<?>, Boolean> previousMockupClasses) {
169	for (Entry<Class<?>, Boolean> mockupClassAndData : previousMockupClasses.entrySet()) {	1✔
170	Class<?> mockupClass = mockupClassAndData.getKey();	1✔
171	MockUpInstances mockUpData = mockupClassesToMockupInstances.get(mockupClass);	1✔
172	mockUpData.hasMockupsForSingleInstances = mockupClassAndData.getValue();	1✔
173	}	1✔
174	}	1✔
175
176	private void discardAllMockupInstances() {
177	if (!mockupClassesToMockupInstances.isEmpty()) {	1✔
178	for (MockUpInstances mockUpInstances : mockupClassesToMockupInstances.values()) {	1✔
179	mockUpInstances.notifyMockUpOfTearDown();	1✔
180	}	1✔
181
182	mockupClassesToMockupInstances.clear();	1✔
183	}
184	}	1✔
185
186	public void discardStartupFakes() {
187	for (MockUp<?> startupMockup : startupMocks.values()) {	1✔
188	notifyOfTearDown(startupMockup);	1✔
189	}	1✔
190	}	1✔
191
192	public final class SavePoint {
193	@NonNull
194	private final Map<Object, MockUp<?>> previousMockInstances;
195	@NonNull
196	private final Map<Class<?>, Boolean> previousMockupClasses;
197
198	public SavePoint() {	1✔
199	previousMockInstances = new IdentityHashMap<>(mockedToMockupInstances);	1✔
200	previousMockupClasses = new IdentityHashMap<>();	1✔
201
202	for (Entry<Class<?>, MockUpInstances> mockUpClassAndData : mockupClassesToMockupInstances.entrySet()) {	1✔
203	Class<?> mockUpClass = mockUpClassAndData.getKey();	1✔
204	MockUpInstances mockUpData = mockUpClassAndData.getValue();	1✔
205	previousMockupClasses.put(mockUpClass, mockUpData.hasMockupsForSingleInstances);	1✔
206	}	1✔
207	}	1✔
208
209	public void rollback() {
210	discardMockupInstances(previousMockInstances);	1✔
211
212	if (!previousMockupClasses.isEmpty()) {	1✔
213	discardMockupInstancesExceptPreviousOnes(previousMockupClasses);	1✔
214	} else {
215	discardAllMockupInstances();	1✔
216	}
217	}	1✔
218	}
219	}

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