hazendaz / jmockit1 / 422

Committed 30 Oct 2025 09:23PM UTC coverage: 72.22% (+0.02%) from 72.198%

Build # 422

Build Type

push

github

Committed by

hazendaz

Commit Message

Combine catches

Run Details

5674 of 8356 branches covered (67.9%)

Branch coverage included in aggregate %.

0 of 1 new or added line in 1 file covered. (0.0%)

52 existing lines in 8 files now uncovered.

11929 of 16018 relevant lines covered (74.47%)

0.74 hits per line

Source File
Press 'n' to go to next uncovered line, 'b' for previous

89.52

/main/src/main/java/mockit/internal/expectations/mocking/CaptureOfNewInstances.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 mockit.internal.reflection.FieldReflection.getFieldValue;

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

import java.lang.instrument.ClassDefinition;
import java.util.ArrayList;
import java.util.Collection;
import java.util.HashMap;
import java.util.List;
import java.util.Map;

import mockit.asm.classes.ClassReader;
import mockit.asm.types.JavaType;
import mockit.internal.BaseClassModifier;
import mockit.internal.capturing.CaptureOfImplementations;
import mockit.internal.startup.Startup;
import mockit.internal.state.MockFixture;
import mockit.internal.state.TestRun;
import mockit.internal.util.Utilities;

public class CaptureOfNewInstances extends CaptureOfImplementations<MockedType> {
    protected static final class Capture {
        @NonNull
        final MockedType typeMetadata;
        @Nullable
        private Object originalMockInstance;
        @NonNull
        private final List<Object> instancesCaptured;

        private Capture(@NonNull MockedType typeMetadata, @Nullable Object originalMockInstance) {
            this.typeMetadata = typeMetadata;
            this.originalMockInstance = originalMockInstance;
            instancesCaptured = new ArrayList<>(4);
        }

        private boolean isInstanceAlreadyCaptured(@NonNull Object mock) {
            return Utilities.containsReference(instancesCaptured, mock);
        }

        private boolean captureInstance(@Nullable Object fieldOwner, @NonNull Object instance) {
            if (instancesCaptured.size() < typeMetadata.getMaxInstancesToCapture()) {
                if (fieldOwner != null && typeMetadata.field != null && originalMockInstance == null) {
                    originalMockInstance = getFieldValue(typeMetadata.field, fieldOwner);
                }

                instancesCaptured.add(instance);
                return true;
            }

            return false;
        }

        void reset() {
            originalMockInstance = null;
            instancesCaptured.clear();
        }
    }

    @NonNull
    private final Map<Class<?>, List<Capture>> baseTypeToCaptures;

    CaptureOfNewInstances() {
        baseTypeToCaptures = new HashMap<>();
    }

    @NonNull
    protected final Collection<List<Capture>> getCapturesForAllBaseTypes() {
        return baseTypeToCaptures.values();
    }

    @NonNull
    @Override
    protected BaseClassModifier createModifier(@Nullable ClassLoader cl, @NonNull ClassReader cr,
            @NonNull Class<?> baseType, @Nullable MockedType typeMetadata) {
        MockedClassModifier modifier = new MockedClassModifier(cl, cr, typeMetadata);
        String baseTypeDesc = JavaType.getInternalName(baseType);
        modifier.setClassNameForCapturedInstanceMethods(baseTypeDesc);
        return modifier;
    }

    @Override
    protected void redefineClass(@NonNull Class<?> realClass, @NonNull byte[] modifiedClass) {
        ClassDefinition newClassDefinition = new ClassDefinition(realClass, modifiedClass);
        Startup.redefineMethods(newClassDefinition);

        MockFixture mockFixture = TestRun.mockFixture();
        mockFixture.addRedefinedClass(newClassDefinition);
        mockFixture.registerMockedClass(realClass);
    }

    void registerCaptureOfNewInstances(@NonNull MockedType typeMetadata, @Nullable Object mockInstance) {
        Class<?> baseType = typeMetadata.getClassType();

        if (!typeMetadata.isFinalFieldOrParameter()) {
            makeSureAllSubtypesAreModified(typeMetadata);
        }

        List<Capture> captures = baseTypeToCaptures.computeIfAbsent(baseType, k -> new ArrayList<>());
        captures.add(new Capture(typeMetadata, mockInstance));
    }

    void makeSureAllSubtypesAreModified(@NonNull MockedType typeMetadata) {
        Class<?> baseType = typeMetadata.getClassType();
        makeSureAllSubtypesAreModified(baseType, typeMetadata.fieldFromTestClass, typeMetadata);
    }

    public boolean captureNewInstance(@Nullable Object fieldOwner, @NonNull Object mock) {
        Class<?> mockedClass = mock.getClass();
        List<Capture> captures = baseTypeToCaptures.get(mockedClass);
        boolean constructorModifiedForCaptureOnly = captures == null;

        if (constructorModifiedForCaptureOnly) {
            captures = findCaptures(mockedClass);

            if (captures == null) {
                return false;
            }
        }

        Capture captureFound = findCapture(fieldOwner, mock, captures);

        if (captureFound != null) {
            if (captureFound.typeMetadata.injectable) {
                TestRun.getExecutingTest().addCapturedInstanceForInjectableMock(captureFound.originalMockInstance,
                        mock);
                constructorModifiedForCaptureOnly = true;
            } else {
                TestRun.getExecutingTest().addCapturedInstance(captureFound.originalMockInstance, mock);
            }
        }

        return constructorModifiedForCaptureOnly;
    }

    @Nullable
    private List<Capture> findCaptures(@NonNull Class<?> mockedClass) {
        Class<?>[] interfaces = mockedClass.getInterfaces();

        for (Class<?> anInterface : interfaces) {
            List<Capture> found = baseTypeToCaptures.get(anInterface);

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

        Class<?> superclass = mockedClass.getSuperclass();

        if (superclass == Object.class) {
            return null;
        }

        List<Capture> found = baseTypeToCaptures.get(superclass);

        return found != null ? found : findCaptures(superclass);
    }

    @Nullable
    private static Capture findCapture(@Nullable Object fieldOwner, @NonNull Object mock,
            @NonNull List<Capture> captures) {
        for (Capture capture : captures) {
            if (capture.isInstanceAlreadyCaptured(mock)) {
                break;
            } else if (capture.captureInstance(fieldOwner, mock)) {
                return capture;
            }
        }

        return null;
    }

    public void cleanUp() {
        baseTypeToCaptures.clear();
    }
}

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 mockit.internal.reflection.FieldReflection.getFieldValue;
8
9	import edu.umd.cs.findbugs.annotations.NonNull;
10	import edu.umd.cs.findbugs.annotations.Nullable;
11
12	import java.lang.instrument.ClassDefinition;
13	import java.util.ArrayList;
14	import java.util.Collection;
15	import java.util.HashMap;
16	import java.util.List;
17	import java.util.Map;
18
19	import mockit.asm.classes.ClassReader;
20	import mockit.asm.types.JavaType;
21	import mockit.internal.BaseClassModifier;
22	import mockit.internal.capturing.CaptureOfImplementations;
23	import mockit.internal.startup.Startup;
24	import mockit.internal.state.MockFixture;
25	import mockit.internal.state.TestRun;
26	import mockit.internal.util.Utilities;
27
28	public class CaptureOfNewInstances extends CaptureOfImplementations<MockedType> {
29	protected static final class Capture {
30	@NonNull
31	final MockedType typeMetadata;
32	@Nullable
33	private Object originalMockInstance;
34	@NonNull
35	private final List<Object> instancesCaptured;
36
37	private Capture(@NonNull MockedType typeMetadata, @Nullable Object originalMockInstance) {	1✔
38	this.typeMetadata = typeMetadata;	1✔
39	this.originalMockInstance = originalMockInstance;	1✔
40	instancesCaptured = new ArrayList<>(4);	1✔
41	}	1✔
42
43	private boolean isInstanceAlreadyCaptured(@NonNull Object mock) {
44	return Utilities.containsReference(instancesCaptured, mock);	1✔
45	}
46
47	private boolean captureInstance(@Nullable Object fieldOwner, @NonNull Object instance) {
48	if (instancesCaptured.size() < typeMetadata.getMaxInstancesToCapture()) {	1!
49	if (fieldOwner != null && typeMetadata.field != null && originalMockInstance == null) {	1!
50	originalMockInstance = getFieldValue(typeMetadata.field, fieldOwner);	1✔
51	}
52
53	instancesCaptured.add(instance);	1✔
54	return true;	1✔
55	}
56
57	return false;	×
58	}
59
60	void reset() {
61	originalMockInstance = null;	1✔
62	instancesCaptured.clear();	1✔
63	}	1✔
64	}
65
66	@NonNull
67	private final Map<Class<?>, List<Capture>> baseTypeToCaptures;
68
69	CaptureOfNewInstances() {	1✔
70	baseTypeToCaptures = new HashMap<>();	1✔
71	}	1✔
72
73	@NonNull
74	protected final Collection<List<Capture>> getCapturesForAllBaseTypes() {
75	return baseTypeToCaptures.values();	1✔
76	}
77
78	@NonNull
79	@Override
80	protected BaseClassModifier createModifier(@Nullable ClassLoader cl, @NonNull ClassReader cr,
81	@NonNull Class<?> baseType, @Nullable MockedType typeMetadata) {
82	MockedClassModifier modifier = new MockedClassModifier(cl, cr, typeMetadata);	1✔
83	String baseTypeDesc = JavaType.getInternalName(baseType);	1✔
84	modifier.setClassNameForCapturedInstanceMethods(baseTypeDesc);	1✔
85	return modifier;	1✔
86	}
87
88	@Override
89	protected void redefineClass(@NonNull Class<?> realClass, @NonNull byte[] modifiedClass) {
90	ClassDefinition newClassDefinition = new ClassDefinition(realClass, modifiedClass);	1✔
91	Startup.redefineMethods(newClassDefinition);	1✔
92
93	MockFixture mockFixture = TestRun.mockFixture();	1✔
94	mockFixture.addRedefinedClass(newClassDefinition);	1✔
95	mockFixture.registerMockedClass(realClass);	1✔
96	}	1✔
97
98	void registerCaptureOfNewInstances(@NonNull MockedType typeMetadata, @Nullable Object mockInstance) {
99	Class<?> baseType = typeMetadata.getClassType();	1✔
100
101	if (!typeMetadata.isFinalFieldOrParameter()) {	1✔
102	makeSureAllSubtypesAreModified(typeMetadata);	1✔
103	}
104
105	List<Capture> captures = baseTypeToCaptures.computeIfAbsent(baseType, k -> new ArrayList<>());	1✔
106	captures.add(new Capture(typeMetadata, mockInstance));	1✔
107	}	1✔
108
109	void makeSureAllSubtypesAreModified(@NonNull MockedType typeMetadata) {
110	Class<?> baseType = typeMetadata.getClassType();	1✔
111	makeSureAllSubtypesAreModified(baseType, typeMetadata.fieldFromTestClass, typeMetadata);	1✔
112	}	1✔
113
114	public boolean captureNewInstance(@Nullable Object fieldOwner, @NonNull Object mock) {
115	Class<?> mockedClass = mock.getClass();	1✔
116	List<Capture> captures = baseTypeToCaptures.get(mockedClass);	1✔
117	boolean constructorModifiedForCaptureOnly = captures == null;	1!
118
119	if (constructorModifiedForCaptureOnly) {	1!
120	captures = findCaptures(mockedClass);	1✔
121
122	if (captures == null) {	1✔
123	return false;	1✔
124	}
125	}
126
127	Capture captureFound = findCapture(fieldOwner, mock, captures);	1✔
128
129	if (captureFound != null) {	1✔
130	if (captureFound.typeMetadata.injectable) {	1!
UNCOV 131	TestRun.getExecutingTest().addCapturedInstanceForInjectableMock(captureFound.originalMockInstance,	×
132	mock);
UNCOV 133	constructorModifiedForCaptureOnly = true;	×
134	} else {
135	TestRun.getExecutingTest().addCapturedInstance(captureFound.originalMockInstance, mock);	1✔
136	}
137	}
138
139	return constructorModifiedForCaptureOnly;	1✔
140	}
141
142	@Nullable
143	private List<Capture> findCaptures(@NonNull Class<?> mockedClass) {
144	Class<?>[] interfaces = mockedClass.getInterfaces();	1✔
145
146	for (Class<?> anInterface : interfaces) {	1✔
147	List<Capture> found = baseTypeToCaptures.get(anInterface);	1✔
148
149	if (found != null) {	1✔
150	return found;	1✔
151	}
152	}
153
154	Class<?> superclass = mockedClass.getSuperclass();	1✔
155
156	if (superclass == Object.class) {	1✔
157	return null;	1✔
158	}
159
160	List<Capture> found = baseTypeToCaptures.get(superclass);	1✔
161
162	return found != null ? found : findCaptures(superclass);	1✔
163	}
164
165	@Nullable
166	private static Capture findCapture(@Nullable Object fieldOwner, @NonNull Object mock,
167	@NonNull List<Capture> captures) {
168	for (Capture capture : captures) {	1!
169	if (capture.isInstanceAlreadyCaptured(mock)) {	1✔
170	break;	1✔
171	} else if (capture.captureInstance(fieldOwner, mock)) {	1!
172	return capture;	1✔
173	}
UNCOV 174	}	×
175
176	return null;	1✔
177	}
178
179	public void cleanUp() {
180	baseTypeToCaptures.clear();	1✔
181	}	1✔
182	}

hazendaz / jmockit1 / 422

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