hazendaz / jmockit1 / 982

Committed 18 Jul 2026 04:33PM UTC coverage: 75.582% (+0.05%) from 75.533%

Build # 982

Build Type

push

github

Committed by

hazendaz

Commit Message

Reenable TestedClassWithConstructorD12Test and remove InetAddress as no longer needed

Coverage Stats

6049 of 8498 branches covered (71.18%)

Branch coverage included in aggregate %.

12690 of 16295 relevant lines covered (77.88%)

0.78 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) {	1!
66	// adds the fields to the first public JRE class to be loaded
67	ClassReader cr = new ClassReader(classfileBuffer);	1✔
68
69	if (isPublic(cr.getAccess())) {	1!
70	instrumentation.removeTransformer(this);	1✔
71	hostClassName = className;	1✔
72	return getModifiedJREClassWithAddedFields(cr);	1✔
73	}
74	}
75
76	return null;	×
77	}
78
79	@NonNull
80	private static byte[] getModifiedJREClassWithAddedFields(@NonNull ClassReader classReader) {
81	ClassWriter cw = new ClassWriter(classReader);	1✔
82
83	ClassVisitor cv = new WrappingClassVisitor(cw) {	1✔
84	@Override
85	public void visitEnd() {
86	addField(MockedBridge.MB);	1✔
87	addField(FakeBridge.MB);	1✔
88	addField(FakeMethodBridge.MB);	1✔
89	}	1✔
90
91	private void addField(@NonNull ClassLoadingBridge mb) {
92	cw.visitField(FIELD_ACCESS, mb.id, "Ljava/lang/reflect/InvocationHandler;", null, null);	1✔
93	}	1✔
94	};
95
96	classReader.accept(cv);	1✔
97	return cw.toByteArray();	1✔
98	}
99	}
100	}

hazendaz / jmockit1 / 982

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