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

81.08

/main/src/main/java/mockit/internal/startup/ClassLoadingBridgeFields.java

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

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

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

import java.lang.instrument.ClassFileTransformer;
import java.lang.instrument.Instrumentation;
import java.security.ProtectionDomain;
import java.security.Provider;

import mockit.asm.classes.ClassReader;
import mockit.asm.classes.ClassVisitor;
import mockit.asm.classes.ClassWriter;
import mockit.asm.classes.WrappingClassVisitor;
import mockit.asm.jvmConstants.Access;
import mockit.internal.ClassLoadingBridge;
import mockit.internal.expectations.mocking.MockedBridge;
import mockit.internal.faking.FakeBridge;
import mockit.internal.faking.FakeMethodBridge;

final class ClassLoadingBridgeFields {
    private ClassLoadingBridgeFields() {
    }

    static void createSyntheticFieldsInJREClassToHoldClassLoadingBridges(@NonNull Instrumentation instrumentation) {
        FieldAdditionTransformer fieldAdditionTransformer = new FieldAdditionTransformer(instrumentation);
        instrumentation.addTransformer(fieldAdditionTransformer);

        // Loads some JRE classes expected to not be loaded yet.
        NegativeArraySizeException.class.getName();
        String hostClassName = fieldAdditionTransformer.hostClassName;

        if (hostClassName == null) {
            Provider.class.getName();
            hostClassName = fieldAdditionTransformer.hostClassName;
        }

        ClassLoadingBridge.hostJREClassName = hostClassName;
    }

    private static final class FieldAdditionTransformer implements ClassFileTransformer {
        private static final int FIELD_ACCESS = PUBLIC + STATIC + Access.SYNTHETIC;
        @NonNull
        private final Instrumentation instrumentation;
        String hostClassName;

        FieldAdditionTransformer(@NonNull Instrumentation instrumentation) {
            this.instrumentation = instrumentation;
        }

        @Nullable
        @Override
        public byte[] transform(@Nullable ClassLoader loader, @NonNull String className,
                @Nullable Class<?> classBeingRedefined, @Nullable ProtectionDomain protectionDomain,
                @NonNull byte[] classfileBuffer) {
            if (loader == null && hostClassName == null) { // adds the fields to the first public JRE class to be loaded
                ClassReader cr = new ClassReader(classfileBuffer);

                if (isPublic(cr.getAccess())) {
                    instrumentation.removeTransformer(this);
                    hostClassName = className;
                    return getModifiedJREClassWithAddedFields(cr);
                }
            }

            return null;
        }

        @NonNull
        private static byte[] getModifiedJREClassWithAddedFields(@NonNull ClassReader classReader) {
            ClassWriter cw = new ClassWriter(classReader);

            ClassVisitor cv = new WrappingClassVisitor(cw) {
                @Override
                public void visitEnd() {
                    addField(MockedBridge.MB);
                    addField(FakeBridge.MB);
                    addField(FakeMethodBridge.MB);
                }

                private void addField(@NonNull ClassLoadingBridge mb) {
                    cw.visitField(FIELD_ACCESS, mb.id, "Ljava/lang/reflect/InvocationHandler;", null, null);
                }
            };

            classReader.accept(cv);
            return cw.toByteArray();
        }
    }
}

1	/*
2	* MIT License
3	* Copyright (c) 2006-2025 JMockit developers
4	* See LICENSE file for full license text.
5	*/
6	package mockit.internal.startup;
7
8	import static java.lang.reflect.Modifier.PUBLIC;
9	import static java.lang.reflect.Modifier.STATIC;
10	import static java.lang.reflect.Modifier.isPublic;
11
12	import edu.umd.cs.findbugs.annotations.NonNull;
13	import edu.umd.cs.findbugs.annotations.Nullable;
14
15	import java.lang.instrument.ClassFileTransformer;
16	import java.lang.instrument.Instrumentation;
17	import java.security.ProtectionDomain;
18	import java.security.Provider;
19
20	import mockit.asm.classes.ClassReader;
21	import mockit.asm.classes.ClassVisitor;
22	import mockit.asm.classes.ClassWriter;
23	import mockit.asm.classes.WrappingClassVisitor;
24	import mockit.asm.jvmConstants.Access;
25	import mockit.internal.ClassLoadingBridge;
26	import mockit.internal.expectations.mocking.MockedBridge;
27	import mockit.internal.faking.FakeBridge;
28	import mockit.internal.faking.FakeMethodBridge;
29
30	final class ClassLoadingBridgeFields {
31	private ClassLoadingBridgeFields() {
32	}
33
34	static void createSyntheticFieldsInJREClassToHoldClassLoadingBridges(@NonNull Instrumentation instrumentation) {
35	FieldAdditionTransformer fieldAdditionTransformer = new FieldAdditionTransformer(instrumentation);	1✔
36	instrumentation.addTransformer(fieldAdditionTransformer);	1✔
37
38	// Loads some JRE classes expected to not be loaded yet.
39	NegativeArraySizeException.class.getName();	1✔
40	String hostClassName = fieldAdditionTransformer.hostClassName;	1✔
41
42	if (hostClassName == null) {	1!
43	Provider.class.getName();	×
44	hostClassName = fieldAdditionTransformer.hostClassName;	×
45	}
46
47	ClassLoadingBridge.hostJREClassName = hostClassName;	1✔
48	}	1✔
49
50	private static final class FieldAdditionTransformer implements ClassFileTransformer {
51	private static final int FIELD_ACCESS = PUBLIC + STATIC + Access.SYNTHETIC;
52	@NonNull
53	private final Instrumentation instrumentation;
54	String hostClassName;
55
56	FieldAdditionTransformer(@NonNull Instrumentation instrumentation) {	1✔
57	this.instrumentation = instrumentation;	1✔
58	}	1✔
59
60	@Nullable
61	@Override
62	public byte[] transform(@Nullable ClassLoader loader, @NonNull String className,
63	@Nullable Class<?> classBeingRedefined, @Nullable ProtectionDomain protectionDomain,
64	@NonNull byte[] classfileBuffer) {
65	if (loader == null && hostClassName == null) { // adds the fields to the first public JRE class to be loaded	1!
66	ClassReader cr = new ClassReader(classfileBuffer);	1✔
67
68	if (isPublic(cr.getAccess())) {	1!
69	instrumentation.removeTransformer(this);	1✔
70	hostClassName = className;	1✔
71	return getModifiedJREClassWithAddedFields(cr);	1✔
72	}
73	}
74
75	return null;	×
76	}
77
78	@NonNull
79	private static byte[] getModifiedJREClassWithAddedFields(@NonNull ClassReader classReader) {
80	ClassWriter cw = new ClassWriter(classReader);	1✔
81
82	ClassVisitor cv = new WrappingClassVisitor(cw) {	1✔
83	@Override
84	public void visitEnd() {
85	addField(MockedBridge.MB);	1✔
86	addField(FakeBridge.MB);	1✔
87	addField(FakeMethodBridge.MB);	1✔
88	}	1✔
89
90	private void addField(@NonNull ClassLoadingBridge mb) {
91	cw.visitField(FIELD_ACCESS, mb.id, "Ljava/lang/reflect/InvocationHandler;", null, null);	1✔
92	}	1✔
93	};
94
95	classReader.accept(cv);	1✔
96	return cw.toByteArray();	1✔
97	}
98	}
99	}

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