hazendaz / jmockit1 / 469

Committed 08 Nov 2025 03:55AM UTC coverage: 72.268% (+0.005%) from 72.263%

Build # 469

Build Type

push

github

Committed by

web-flow

Commit Message

Merge pull request #404 from hazendaz/renovate/hibernate-orm-monorepo

Update dependency org.hibernate.orm:hibernate-core to v7.1.7.Final

Run Details

5677 of 8360 branches covered (67.91%)

Branch coverage included in aggregate %.

11939 of 16016 relevant lines covered (74.54%)

0.75 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

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

hazendaz / jmockit1 / 469

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