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

90.58

/main/src/main/java/mockit/internal/expectations/mocking/FieldTypeRedefinitions.java

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

import static java.lang.reflect.Modifier.isFinal;

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

import java.lang.reflect.Field;
import java.util.ArrayList;
import java.util.HashMap;
import java.util.List;
import java.util.Map;
import java.util.Map.Entry;

import mockit.asm.jvmConstants.Access;
import mockit.internal.reflection.FieldReflection;
import mockit.internal.state.TestRun;
import mockit.internal.util.StackTrace;

@SuppressWarnings("UnnecessaryFullyQualifiedName")
public final class FieldTypeRedefinitions extends TypeRedefinitions {
    private static final int FIELD_ACCESS_MASK = Access.SYNTHETIC + Access.STATIC;

    @NonNull
    private final Map<MockedType, InstanceFactory> mockInstanceFactories;
    @NonNull
    private final List<MockedType> mockFieldsNotSet;

    public FieldTypeRedefinitions(@NonNull Class<?> testClass) {
        mockInstanceFactories = new HashMap<>();
        mockFieldsNotSet = new ArrayList<>();

        TestRun.enterNoMockingZone();

        try {
            redefineFieldTypes(testClass);
        } finally {
            TestRun.exitNoMockingZone();
        }
    }

    private void redefineFieldTypes(@NonNull Class<?> classWithMockFields) {
        Class<?> superClass = classWithMockFields.getSuperclass();

        if (superClass != null && superClass != Object.class && superClass != mockit.Expectations.class) {
            redefineFieldTypes(superClass);
        }

        Field[] fields = classWithMockFields.getDeclaredFields();

        for (Field candidateField : fields) {
            int fieldModifiers = candidateField.getModifiers();

            if ((fieldModifiers & FIELD_ACCESS_MASK) == 0) {
                redefineFieldType(candidateField, fieldModifiers);
            }
        }
    }

    private void redefineFieldType(@NonNull Field field, int modifiers) {
        MockedType mockedType = new MockedType(field);

        if (mockedType.isMockableType()) {
            boolean partialMocking = field.isAnnotationPresent(mockit.Tested.class);
            boolean needsValueToSet = !isFinal(modifiers) && !partialMocking;

            redefineFieldType(mockedType, partialMocking, needsValueToSet);

            if (!partialMocking) {
                registerCaptureOfNewInstances(mockedType);
            }
        }
    }

    private void redefineFieldType(@NonNull MockedType mockedType, boolean partialMocking, boolean needsValueToSet) {
        FieldTypeRedefinition typeRedefinition = new FieldTypeRedefinition(mockedType);
        boolean redefined;

        if (needsValueToSet) {
            InstanceFactory factory = typeRedefinition.redefineType();
            redefined = factory != null;

            if (redefined) {
                mockInstanceFactories.put(mockedType, factory);
            }
        } else {
            if (partialMocking) {
                redefined = typeRedefinition.redefineTypeForTestedField();
            } else {
                redefined = typeRedefinition.redefineTypeForFinalField();
            }

            if (redefined) {
                mockFieldsNotSet.add(mockedType);
            }
        }

        if (redefined) {
            addTargetClass(mockedType);
        }
    }

    private void registerCaptureOfNewInstances(@NonNull MockedType mockedType) {
        if (mockedType.getMaxInstancesToCapture() > 0) {
            if (captureOfNewInstances == null) {
                captureOfNewInstances = new CaptureOfNewInstancesForFields();
            }

            captureOfNewInstances.registerCaptureOfNewInstances(mockedType, null);
        }
    }

    public void assignNewInstancesToMockFields(@NonNull Object target) {
        TestRun.getExecutingTest().clearRegularAndInjectableMocks();
        createAndAssignNewInstances(target);
        obtainAndRegisterInstancesOfFieldsNotSet(target);
    }

    private void createAndAssignNewInstances(@NonNull Object target) {
        for (Entry<MockedType, InstanceFactory> metadataAndFactory : mockInstanceFactories.entrySet()) {
            MockedType mockedType = metadataAndFactory.getKey();
            InstanceFactory instanceFactory = metadataAndFactory.getValue();

            Object mock = assignNewInstanceToMockField(target, mockedType, instanceFactory);
            registerMock(mockedType, mock);
        }
    }

    @NonNull
    private Object assignNewInstanceToMockField(@NonNull Object target, @NonNull MockedType mockedType,
            @NonNull InstanceFactory instanceFactory) {
        Field mockField = mockedType.field;
        assert mockField != null;
        Object mock = FieldReflection.getFieldValue(mockField, target);

        if (mock == null) {
            try {
                mock = instanceFactory.create();
            } catch (NoClassDefFoundError | ExceptionInInitializerError e) {
                StackTrace.filterStackTrace(e);
                e.printStackTrace();
                throw e;
            }

            FieldReflection.setFieldValue(mockField, target, mock);

            if (mockedType.getMaxInstancesToCapture() > 0) {
                assert captureOfNewInstances != null;
                CaptureOfNewInstancesForFields capture = (CaptureOfNewInstancesForFields) captureOfNewInstances;
                capture.resetCaptureCount(mockField);
            }
        }

        return mock;
    }

    private void obtainAndRegisterInstancesOfFieldsNotSet(@NonNull Object target) {
        for (MockedType metadata : mockFieldsNotSet) {
            assert metadata.field != null;
            Object mock = FieldReflection.getFieldValue(metadata.field, target);

            if (mock != null) {
                registerMock(metadata, mock);
            }
        }
    }

    /**
     * Returns true iff the mock instance concrete class is not mocked in some test, i.e. it's a class which only
     * appears in the code under test.
     */
    public boolean captureNewInstanceForApplicableMockField(@NonNull Object mock) {
        if (captureOfNewInstances == null) {
            return false;
        }

        Object fieldOwner = TestRun.getCurrentTestInstance();
        return captureOfNewInstances.captureNewInstance(fieldOwner, mock);
    }

    @Override
    public void cleanUp() {
        TestRun.getExecutingTest().getCascadingTypes().clear();
        super.cleanUp();
    }
}

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.mocking;
7
8	import static java.lang.reflect.Modifier.isFinal;
9
10	import edu.umd.cs.findbugs.annotations.NonNull;
11
12	import java.lang.reflect.Field;
13	import java.util.ArrayList;
14	import java.util.HashMap;
15	import java.util.List;
16	import java.util.Map;
17	import java.util.Map.Entry;
18
19	import mockit.asm.jvmConstants.Access;
20	import mockit.internal.reflection.FieldReflection;
21	import mockit.internal.state.TestRun;
22	import mockit.internal.util.StackTrace;
23
24	@SuppressWarnings("UnnecessaryFullyQualifiedName")	1✔
25	public final class FieldTypeRedefinitions extends TypeRedefinitions {
26	private static final int FIELD_ACCESS_MASK = Access.SYNTHETIC + Access.STATIC;
27
28	@NonNull
29	private final Map<MockedType, InstanceFactory> mockInstanceFactories;
30	@NonNull
31	private final List<MockedType> mockFieldsNotSet;
32
33	public FieldTypeRedefinitions(@NonNull Class<?> testClass) {	1✔
34	mockInstanceFactories = new HashMap<>();	1✔
35	mockFieldsNotSet = new ArrayList<>();	1✔
36
37	TestRun.enterNoMockingZone();	1✔
38
39	try {
40	redefineFieldTypes(testClass);	1✔
41	} finally {
42	TestRun.exitNoMockingZone();	1✔
43	}
44	}	1✔
45
46	private void redefineFieldTypes(@NonNull Class<?> classWithMockFields) {
47	Class<?> superClass = classWithMockFields.getSuperclass();	1✔
48
49	if (superClass != null && superClass != Object.class && superClass != mockit.Expectations.class) {	1!
50	redefineFieldTypes(superClass);	1✔
51	}
52
53	Field[] fields = classWithMockFields.getDeclaredFields();	1✔
54
55	for (Field candidateField : fields) {	1✔
56	int fieldModifiers = candidateField.getModifiers();	1✔
57
58	if ((fieldModifiers & FIELD_ACCESS_MASK) == 0) {	1✔
59	redefineFieldType(candidateField, fieldModifiers);	1✔
60	}
61	}
62	}	1✔
63
64	private void redefineFieldType(@NonNull Field field, int modifiers) {
65	MockedType mockedType = new MockedType(field);	1✔
66
67	if (mockedType.isMockableType()) {	1✔
68	boolean partialMocking = field.isAnnotationPresent(mockit.Tested.class);	1✔
69	boolean needsValueToSet = !isFinal(modifiers) && !partialMocking;	1✔
70
71	redefineFieldType(mockedType, partialMocking, needsValueToSet);	1✔
72
73	if (!partialMocking) {	1✔
74	registerCaptureOfNewInstances(mockedType);	1✔
75	}
76	}
77	}	1✔
78
79	private void redefineFieldType(@NonNull MockedType mockedType, boolean partialMocking, boolean needsValueToSet) {
80	FieldTypeRedefinition typeRedefinition = new FieldTypeRedefinition(mockedType);	1✔
81	boolean redefined;
82
83	if (needsValueToSet) {	1✔
84	InstanceFactory factory = typeRedefinition.redefineType();	1✔
85	redefined = factory != null;	1!
86
87	if (redefined) {	1!
88	mockInstanceFactories.put(mockedType, factory);	1✔
89	}
90	} else {	1✔
91	if (partialMocking) {	1✔
92	redefined = typeRedefinition.redefineTypeForTestedField();	1✔
93	} else {
94	redefined = typeRedefinition.redefineTypeForFinalField();	1✔
95	}
96
97	if (redefined) {	1!
98	mockFieldsNotSet.add(mockedType);	1✔
99	}
100	}
101
102	if (redefined) {	1!
103	addTargetClass(mockedType);	1✔
104	}
105	}	1✔
106
107	private void registerCaptureOfNewInstances(@NonNull MockedType mockedType) {
108	if (mockedType.getMaxInstancesToCapture() > 0) {	1✔
109	if (captureOfNewInstances == null) {	1✔
110	captureOfNewInstances = new CaptureOfNewInstancesForFields();	1✔
111	}
112
113	captureOfNewInstances.registerCaptureOfNewInstances(mockedType, null);	1✔
114	}
115	}	1✔
116
117	public void assignNewInstancesToMockFields(@NonNull Object target) {
118	TestRun.getExecutingTest().clearRegularAndInjectableMocks();	1✔
119	createAndAssignNewInstances(target);	1✔
120	obtainAndRegisterInstancesOfFieldsNotSet(target);	1✔
121	}	1✔
122
123	private void createAndAssignNewInstances(@NonNull Object target) {
124	for (Entry<MockedType, InstanceFactory> metadataAndFactory : mockInstanceFactories.entrySet()) {	1✔
125	MockedType mockedType = metadataAndFactory.getKey();	1✔
126	InstanceFactory instanceFactory = metadataAndFactory.getValue();	1✔
127
128	Object mock = assignNewInstanceToMockField(target, mockedType, instanceFactory);	1✔
129	registerMock(mockedType, mock);	1✔
130	}	1✔
131	}	1✔
132
133	@NonNull
134	private Object assignNewInstanceToMockField(@NonNull Object target, @NonNull MockedType mockedType,
135	@NonNull InstanceFactory instanceFactory) {
136	Field mockField = mockedType.field;	1✔
137	assert mockField != null;	1!
138	Object mock = FieldReflection.getFieldValue(mockField, target);	1✔
139
140	if (mock == null) {	1✔
141	try {
142	mock = instanceFactory.create();	1✔
143	} catch (NoClassDefFoundError \| ExceptionInInitializerError e) {	×
144	StackTrace.filterStackTrace(e);	×
145	e.printStackTrace();	×
146	throw e;	×
147	}	1✔
148
149	FieldReflection.setFieldValue(mockField, target, mock);	1✔
150
151	if (mockedType.getMaxInstancesToCapture() > 0) {	1✔
152	assert captureOfNewInstances != null;	1!
153	CaptureOfNewInstancesForFields capture = (CaptureOfNewInstancesForFields) captureOfNewInstances;	1✔
154	capture.resetCaptureCount(mockField);	1✔
155	}
156	}
157
158	return mock;	1✔
159	}
160
161	private void obtainAndRegisterInstancesOfFieldsNotSet(@NonNull Object target) {
162	for (MockedType metadata : mockFieldsNotSet) {	1✔
163	assert metadata.field != null;	1!
164	Object mock = FieldReflection.getFieldValue(metadata.field, target);	1✔
165
166	if (mock != null) {	1✔
167	registerMock(metadata, mock);	1✔
168	}
169	}	1✔
170	}	1✔
171
172	/**
173	* Returns true iff the mock instance concrete class is not mocked in some test, i.e. it's a class which only
174	* appears in the code under test.
175	*/
176	public boolean captureNewInstanceForApplicableMockField(@NonNull Object mock) {
177	if (captureOfNewInstances == null) {	1✔
178	return false;	1✔
179	}
180
181	Object fieldOwner = TestRun.getCurrentTestInstance();	1✔
182	return captureOfNewInstances.captureNewInstance(fieldOwner, mock);	1✔
183	}
184
185	@Override
186	public void cleanUp() {
187	TestRun.getExecutingTest().getCascadingTypes().clear();	1✔
188	super.cleanUp();	1✔
189	}	1✔
190	}

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