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

58.96

/main/src/main/java/mockit/internal/ClassFile.java

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

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

import java.io.IOException;
import java.io.InputStream;
import java.util.Map;
import java.util.concurrent.ConcurrentHashMap;

import mockit.asm.classes.ClassReader;
import mockit.internal.state.CachedClassfiles;
import mockit.internal.state.TestRun;

public final class ClassFile {
    private static final Map<String, ClassReader> CLASS_FILES = new ConcurrentHashMap<>();

    private ClassFile() {
    }

    public static final class NotFoundException extends RuntimeException {
        private static final long serialVersionUID = 1L;

        private NotFoundException(@NonNull String classNameOrDesc) {
            super("Unable to find class file for " + classNameOrDesc.replace('/', '.'));
        }
    }

    private static void verifyClassFileFound(@Nullable InputStream classFile, @NonNull String classNameOrDesc) {
        if (classFile == null) {
            throw new NotFoundException(classNameOrDesc);
        }
    }

    @Nullable
    public static ClassReader createClassReader(@NonNull ClassLoader cl, @NonNull String internalClassName) {
        String classFileName = internalClassName + ".class";
        InputStream classFile = cl.getResourceAsStream(classFileName);

        if (classFile != null) { // ignore the class if the ".class" file wasn't located
            try {
                byte[] bytecode = readClass(classFile);
                return new ClassReader(bytecode);
            } catch (IOException ignore) {
            }
        }

        return null;
    }

    @NonNull
    private static byte[] readClass(@NonNull InputStream is) throws IOException {
        try {
            byte[] bytecode = new byte[is.available()];
            int len = 0;

            while (true) {
                int n = is.read(bytecode, len, bytecode.length - len);

                if (n == -1) {
                    if (len < bytecode.length) {
                        byte[] truncatedCopy = new byte[len];
                        System.arraycopy(bytecode, 0, truncatedCopy, 0, len);
                        bytecode = truncatedCopy;
                    }

                    return bytecode;
                }

                len += n;

                if (len == bytecode.length) {
                    int last = is.read();

                    if (last < 0) {
                        return bytecode;
                    }

                    byte[] lengthenedCopy = new byte[bytecode.length + 1000];
                    System.arraycopy(bytecode, 0, lengthenedCopy, 0, len);
                    // noinspection NumericCastThatLosesPrecision
                    lengthenedCopy[len] = (byte) last;
                    len++;
                    bytecode = lengthenedCopy;
                }
            }
        } finally {
            is.close();
        }
    }

    @NonNull
    public static ClassReader createReaderOrGetFromCache(@NonNull Class<?> aClass) {
        byte[] cachedClassfile = CachedClassfiles.getClassfile(aClass);

        if (cachedClassfile != null) {
            return new ClassReader(cachedClassfile);
        }

        String classDesc = aClass.getName().replace('.', '/');
        ClassReader reader = CLASS_FILES.get(classDesc);

        if (reader == null) {
            reader = readFromFileSavingInCache(classDesc);
        }

        return reader;
    }

    @NonNull
    private static ClassReader readFromFileSavingInCache(@NonNull String classDesc) {
        byte[] classfileBytes = readBytesFromClassFile(classDesc);
        ClassReader cr = new ClassReader(classfileBytes);
        CLASS_FILES.put(classDesc, cr);
        return cr;
    }

    @NonNull
    public static ClassReader createReaderFromLastRedefinitionIfAny(@NonNull Class<?> aClass) {
        byte[] classfile = TestRun.mockFixture().getRedefinedClassfile(aClass);

        if (classfile == null) {
            classfile = CachedClassfiles.getClassfile(aClass);
        }

        if (classfile != null) {
            return new ClassReader(classfile);
        }

        String classDesc = aClass.getName().replace('.', '/');
        return readFromFileSavingInCache(classDesc);
    }

    @NonNull
    public static byte[] getClassFile(@NonNull String internalClassName) {
        byte[] classfileBytes = CachedClassfiles.getClassfile(internalClassName);

        if (classfileBytes == null) {
            classfileBytes = readBytesFromClassFile(internalClassName);
        }

        return classfileBytes;
    }

    @NonNull
    public static byte[] getClassFile(@Nullable ClassLoader loader, @NonNull String internalClassName) {
        byte[] classfileBytes = CachedClassfiles.getClassfile(loader, internalClassName);

        if (classfileBytes == null) {
            classfileBytes = readBytesFromClassFile(internalClassName);
        }

        return classfileBytes;
    }

    @NonNull
    public static byte[] getClassFile(@NonNull Class<?> aClass) {
        byte[] classfileBytes = CachedClassfiles.getClassfile(aClass);

        if (classfileBytes == null) {
            classfileBytes = readBytesFromClassFile(aClass);
        }

        return classfileBytes;
    }

    @NonNull
    public static byte[] readBytesFromClassFile(@NonNull String classDesc) {
        if (classDesc.startsWith("java/") || classDesc.startsWith("javax/") || classDesc.startsWith("jakarta/")) {
            byte[] classfile = CachedClassfiles.getClassfile(classDesc);

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

        InputStream classFile = readClassFromClasspath(classDesc);

        try {
            return readClass(classFile);
        } catch (IOException e) {
            throw new RuntimeException("Failed to read class file for " + classDesc.replace('/', '.'), e);
        }
    }

    @NonNull
    public static byte[] readBytesFromClassFile(@NonNull Class<?> aClass) {
        String classDesc = aClass.getName().replace('.', '/');
        return readBytesFromClassFile(classDesc);
    }

    @NonNull
    @SuppressWarnings("IOResourceOpenedButNotSafelyClosed")
    private static InputStream readClassFromClasspath(@NonNull String classDesc) {
        String classFileName = classDesc + ".class";
        ClassLoader contextClassLoader = Thread.currentThread().getContextClassLoader();
        InputStream inputStream = null;

        if (contextClassLoader != null) {
            inputStream = contextClassLoader.getResourceAsStream(classFileName);
        }

        if (inputStream == null) {
            ClassLoader thisClassLoader = ClassFile.class.getClassLoader();

            if (thisClassLoader != contextClassLoader) {
                inputStream = thisClassLoader.getResourceAsStream(classFileName);

                if (inputStream == null) {
                    Class<?> testClass = TestRun.getCurrentTestClass();

                    if (testClass != null) {
                        inputStream = testClass.getClassLoader().getResourceAsStream(classFileName);
                    }
                }
            }
        }

        verifyClassFileFound(inputStream, classDesc);
        return inputStream;
    }
}

1	/*
2	* MIT License
3	* Copyright (c) 2006-2025 JMockit developers
4	* See LICENSE file for full license text.
5	*/
6	package mockit.internal;
7
8	import edu.umd.cs.findbugs.annotations.NonNull;
9	import edu.umd.cs.findbugs.annotations.Nullable;
10
11	import java.io.IOException;
12	import java.io.InputStream;
13	import java.util.Map;
14	import java.util.concurrent.ConcurrentHashMap;
15
16	import mockit.asm.classes.ClassReader;
17	import mockit.internal.state.CachedClassfiles;
18	import mockit.internal.state.TestRun;
19
20	public final class ClassFile {
21	private static final Map<String, ClassReader> CLASS_FILES = new ConcurrentHashMap<>();	1✔
22
23	private ClassFile() {
24	}
25
26	public static final class NotFoundException extends RuntimeException {
27	private static final long serialVersionUID = 1L;
28
29	private NotFoundException(@NonNull String classNameOrDesc) {
30	super("Unable to find class file for " + classNameOrDesc.replace('/', '.'));	1✔
31	}	1✔
32	}
33
34	private static void verifyClassFileFound(@Nullable InputStream classFile, @NonNull String classNameOrDesc) {
35	if (classFile == null) {	1✔
36	throw new NotFoundException(classNameOrDesc);	1✔
37	}
38	}	1✔
39
40	@Nullable
41	public static ClassReader createClassReader(@NonNull ClassLoader cl, @NonNull String internalClassName) {
42	String classFileName = internalClassName + ".class";	×
43	InputStream classFile = cl.getResourceAsStream(classFileName);	×
44
45	if (classFile != null) { // ignore the class if the ".class" file wasn't located	×
46	try {
47	byte[] bytecode = readClass(classFile);	×
48	return new ClassReader(bytecode);	×
49	} catch (IOException ignore) {	×
50	}
51	}
52
53	return null;	×
54	}
55
56	@NonNull
57	private static byte[] readClass(@NonNull InputStream is) throws IOException {
58	try {
59	byte[] bytecode = new byte[is.available()];	1✔
60	int len = 0;	1✔
61
62	while (true) {
63	int n = is.read(bytecode, len, bytecode.length - len);	1✔
64
65	if (n == -1) {	1!
66	if (len < bytecode.length) {	×
67	byte[] truncatedCopy = new byte[len];	×
68	System.arraycopy(bytecode, 0, truncatedCopy, 0, len);	×
69	bytecode = truncatedCopy;	×
70	}
71
72	return bytecode;	×
73	}
74
75	len += n;	1✔
76
77	if (len == bytecode.length) {	1!
78	int last = is.read();	1✔
79
80	if (last < 0) {	1!
81	return bytecode;	1✔
82	}
83
84	byte[] lengthenedCopy = new byte[bytecode.length + 1000];	×
85	System.arraycopy(bytecode, 0, lengthenedCopy, 0, len);	×
86	// noinspection NumericCastThatLosesPrecision
87	lengthenedCopy[len] = (byte) last;	×
88	len++;	×
89	bytecode = lengthenedCopy;	×
90	}
91	}	×
92	} finally {
93	is.close();	1✔
94	}
95	}
96
97	@NonNull
98	public static ClassReader createReaderOrGetFromCache(@NonNull Class<?> aClass) {
99	byte[] cachedClassfile = CachedClassfiles.getClassfile(aClass);	1✔
100
101	if (cachedClassfile != null) {	1✔
102	return new ClassReader(cachedClassfile);	1✔
103	}
104
105	String classDesc = aClass.getName().replace('.', '/');	1✔
106	ClassReader reader = CLASS_FILES.get(classDesc);	1✔
107
108	if (reader == null) {	1!
109	reader = readFromFileSavingInCache(classDesc);	×
110	}
111
112	return reader;	×
113	}
114
115	@NonNull
116	private static ClassReader readFromFileSavingInCache(@NonNull String classDesc) {
117	byte[] classfileBytes = readBytesFromClassFile(classDesc);	×
118	ClassReader cr = new ClassReader(classfileBytes);	×
119	CLASS_FILES.put(classDesc, cr);	×
120	return cr;	×
121	}
122
123	@NonNull
124	public static ClassReader createReaderFromLastRedefinitionIfAny(@NonNull Class<?> aClass) {
125	byte[] classfile = TestRun.mockFixture().getRedefinedClassfile(aClass);	1✔
126
127	if (classfile == null) {	1✔
128	classfile = CachedClassfiles.getClassfile(aClass);	1✔
129	}
130
131	if (classfile != null) {	1!
132	return new ClassReader(classfile);	1✔
133	}
134
135	String classDesc = aClass.getName().replace('.', '/');	×
136	return readFromFileSavingInCache(classDesc);	×
137	}
138
139	@NonNull
140	public static byte[] getClassFile(@NonNull String internalClassName) {
141	byte[] classfileBytes = CachedClassfiles.getClassfile(internalClassName);	1✔
142
143	if (classfileBytes == null) {	1!
144	classfileBytes = readBytesFromClassFile(internalClassName);	×
145	}
146
147	return classfileBytes;	1✔
148	}
149
150	@NonNull
151	public static byte[] getClassFile(@Nullable ClassLoader loader, @NonNull String internalClassName) {
152	byte[] classfileBytes = CachedClassfiles.getClassfile(loader, internalClassName);	1✔
153
154	if (classfileBytes == null) {	1✔
155	classfileBytes = readBytesFromClassFile(internalClassName);	1✔
156	}
157
158	return classfileBytes;	1✔
159	}
160
161	@NonNull
162	public static byte[] getClassFile(@NonNull Class<?> aClass) {
163	byte[] classfileBytes = CachedClassfiles.getClassfile(aClass);	1✔
164
165	if (classfileBytes == null) {	1!
166	classfileBytes = readBytesFromClassFile(aClass);	×
167	}
168
169	return classfileBytes;	1✔
170	}
171
172	@NonNull
173	public static byte[] readBytesFromClassFile(@NonNull String classDesc) {
174	if (classDesc.startsWith("java/") \|\| classDesc.startsWith("javax/") \|\| classDesc.startsWith("jakarta/")) {	1!
175	byte[] classfile = CachedClassfiles.getClassfile(classDesc);	1✔
176
177	if (classfile != null) {	1!
178	return classfile;	×
179	}
180	}
181
182	InputStream classFile = readClassFromClasspath(classDesc);	1✔
183
184	try {
185	return readClass(classFile);	1✔
186	} catch (IOException e) {	×
187	throw new RuntimeException("Failed to read class file for " + classDesc.replace('/', '.'), e);	×
188	}
189	}
190
191	@NonNull
192	public static byte[] readBytesFromClassFile(@NonNull Class<?> aClass) {
193	String classDesc = aClass.getName().replace('.', '/');	1✔
194	return readBytesFromClassFile(classDesc);	1✔
195	}
196
197	@NonNull
198	@SuppressWarnings("IOResourceOpenedButNotSafelyClosed")
199	private static InputStream readClassFromClasspath(@NonNull String classDesc) {
200	String classFileName = classDesc + ".class";	1✔
201	ClassLoader contextClassLoader = Thread.currentThread().getContextClassLoader();	1✔
202	InputStream inputStream = null;	1✔
203
204	if (contextClassLoader != null) {	1!
205	inputStream = contextClassLoader.getResourceAsStream(classFileName);	1✔
206	}
207
208	if (inputStream == null) {	1✔
209	ClassLoader thisClassLoader = ClassFile.class.getClassLoader();	1✔
210
211	if (thisClassLoader != contextClassLoader) {	1!
212	inputStream = thisClassLoader.getResourceAsStream(classFileName);	×
213
214	if (inputStream == null) {	×
215	Class<?> testClass = TestRun.getCurrentTestClass();	×
216
217	if (testClass != null) {	×
218	inputStream = testClass.getClassLoader().getResourceAsStream(classFileName);	×
219	}
220	}
221	}
222	}
223
224	verifyClassFileFound(inputStream, classDesc);	1✔
225	return inputStream;	1✔
226	}
227	}

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