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

86.21

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

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

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

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

import java.lang.reflect.Proxy;
import java.lang.reflect.Type;

import mockit.MockUp;
import mockit.asm.classes.ClassReader;
import mockit.asm.classes.ClassVisitor;
import mockit.internal.classGeneration.ImplementationClass;
import mockit.internal.expectations.mocking.InterfaceImplementationGenerator;
import mockit.internal.util.Utilities;

public final class FakedImplementationClass<T> {
    private static final ClassLoader THIS_CL = FakedImplementationClass.class.getClassLoader();

    @NonNull
    private final MockUp<?> fakeInstance;
    @Nullable
    private ImplementationClass<T> implementationClass;
    private Class<T> generatedClass;

    public FakedImplementationClass(@NonNull MockUp<?> fakeInstance) {
        this.fakeInstance = fakeInstance;
    }

    @NonNull
    public Class<T> createImplementation(@NonNull Class<T> interfaceToBeFaked, @Nullable Type typeToFake) {
        createImplementation(interfaceToBeFaked);
        byte[] generatedBytecode = implementationClass == null ? null : implementationClass.getGeneratedBytecode();

        FakeClassSetup fakeClassSetup = new FakeClassSetup(generatedClass, typeToFake, fakeInstance, generatedBytecode);
        fakeClassSetup.redefineMethodsInGeneratedClass();

        return generatedClass;
    }

    @NonNull
    Class<T> createImplementation(@NonNull Class<T> interfaceToBeFaked) {
        if (isPublic(interfaceToBeFaked.getModifiers())) {
            generateImplementationForPublicInterface(interfaceToBeFaked);
        } else {
            // noinspection unchecked
            generatedClass = (Class<T>) Proxy.getProxyClass(interfaceToBeFaked.getClassLoader(), interfaceToBeFaked);
        }

        return generatedClass;
    }

    private void generateImplementationForPublicInterface(@NonNull Class<T> interfaceToBeFaked) {
        implementationClass = new ImplementationClass<T>(interfaceToBeFaked) {
            @NonNull
            @Override
            protected ClassVisitor createMethodBodyGenerator(@NonNull ClassReader typeReader) {
                return new InterfaceImplementationGenerator(typeReader, interfaceToBeFaked, generatedClassName);
            }
        };

        generatedClass = implementationClass.generateClass();
    }

    @NonNull
    public Class<T> createImplementation(@NonNull Type[] interfacesToBeFaked) {
        Class<?>[] interfacesToFake = new Class<?>[interfacesToBeFaked.length];

        for (int i = 0; i < interfacesToFake.length; i++) {
            interfacesToFake[i] = Utilities.getClassType(interfacesToBeFaked[i]);
        }

        // noinspection unchecked
        generatedClass = (Class<T>) Proxy.getProxyClass(THIS_CL, interfacesToFake);
        new FakeClassSetup(generatedClass, null, fakeInstance, null).redefineMethods();

        return generatedClass;
    }
}

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 static java.lang.reflect.Modifier.isPublic;
9
10	import edu.umd.cs.findbugs.annotations.NonNull;
11	import edu.umd.cs.findbugs.annotations.Nullable;
12
13	import java.lang.reflect.Proxy;
14	import java.lang.reflect.Type;
15
16	import mockit.MockUp;
17	import mockit.asm.classes.ClassReader;
18	import mockit.asm.classes.ClassVisitor;
19	import mockit.internal.classGeneration.ImplementationClass;
20	import mockit.internal.expectations.mocking.InterfaceImplementationGenerator;
21	import mockit.internal.util.Utilities;
22
23	public final class FakedImplementationClass<T> {
24	private static final ClassLoader THIS_CL = FakedImplementationClass.class.getClassLoader();	1✔
25
26	@NonNull
27	private final MockUp<?> fakeInstance;
28	@Nullable
29	private ImplementationClass<T> implementationClass;
30	private Class<T> generatedClass;
31
32	public FakedImplementationClass(@NonNull MockUp<?> fakeInstance) {	1✔
33	this.fakeInstance = fakeInstance;	1✔
34	}	1✔
35
36	@NonNull
37	public Class<T> createImplementation(@NonNull Class<T> interfaceToBeFaked, @Nullable Type typeToFake) {
38	createImplementation(interfaceToBeFaked);	1✔
39	byte[] generatedBytecode = implementationClass == null ? null : implementationClass.getGeneratedBytecode();	1✔
40
41	FakeClassSetup fakeClassSetup = new FakeClassSetup(generatedClass, typeToFake, fakeInstance, generatedBytecode);	1✔
42	fakeClassSetup.redefineMethodsInGeneratedClass();	1✔
43
44	return generatedClass;	1✔
45	}
46
47	@NonNull
48	Class<T> createImplementation(@NonNull Class<T> interfaceToBeFaked) {
49	if (isPublic(interfaceToBeFaked.getModifiers())) {	1✔
50	generateImplementationForPublicInterface(interfaceToBeFaked);	1✔
51	} else {
52	// noinspection unchecked
53	generatedClass = (Class<T>) Proxy.getProxyClass(interfaceToBeFaked.getClassLoader(), interfaceToBeFaked);	1✔
54	}
55
56	return generatedClass;	1✔
57	}
58
59	private void generateImplementationForPublicInterface(@NonNull Class<T> interfaceToBeFaked) {
60	implementationClass = new ImplementationClass<T>(interfaceToBeFaked) {	1✔
61	@NonNull
62	@Override
63	protected ClassVisitor createMethodBodyGenerator(@NonNull ClassReader typeReader) {
64	return new InterfaceImplementationGenerator(typeReader, interfaceToBeFaked, generatedClassName);	1✔
65	}
66	};
67
68	generatedClass = implementationClass.generateClass();	1✔
69	}	1✔
70
71	@NonNull
72	public Class<T> createImplementation(@NonNull Type[] interfacesToBeFaked) {
73	Class<?>[] interfacesToFake = new Class<?>[interfacesToBeFaked.length];	1✔
74
75	for (int i = 0; i < interfacesToFake.length; i++) {	1!
76	interfacesToFake[i] = Utilities.getClassType(interfacesToBeFaked[i]);	1✔
77	}
78
79	// noinspection unchecked
80	generatedClass = (Class<T>) Proxy.getProxyClass(THIS_CL, interfacesToFake);	×
81	new FakeClassSetup(generatedClass, null, fakeInstance, null).redefineMethods();	×
82
83	return generatedClass;	×
84	}
85	}

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