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

88.57

/main/src/main/java/mockit/asm/classes/ConstantPoolCopying.java

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

import static mockit.asm.jvmConstants.ConstantPoolTypes.CLASS;
import static mockit.asm.jvmConstants.ConstantPoolTypes.DOUBLE;
import static mockit.asm.jvmConstants.ConstantPoolTypes.DYNAMIC;
import static mockit.asm.jvmConstants.ConstantPoolTypes.FIELD_REF;
import static mockit.asm.jvmConstants.ConstantPoolTypes.FLOAT;
import static mockit.asm.jvmConstants.ConstantPoolTypes.IMETHOD_REF;
import static mockit.asm.jvmConstants.ConstantPoolTypes.INTEGER;
import static mockit.asm.jvmConstants.ConstantPoolTypes.INVOKE_DYNAMIC;
import static mockit.asm.jvmConstants.ConstantPoolTypes.LONG;
import static mockit.asm.jvmConstants.ConstantPoolTypes.METHOD_HANDLE;
import static mockit.asm.jvmConstants.ConstantPoolTypes.METHOD_REF;
import static mockit.asm.jvmConstants.ConstantPoolTypes.METHOD_TYPE;
import static mockit.asm.jvmConstants.ConstantPoolTypes.MODULE;
import static mockit.asm.jvmConstants.ConstantPoolTypes.NAME_TYPE;
import static mockit.asm.jvmConstants.ConstantPoolTypes.PACKAGE;
import static mockit.asm.jvmConstants.ConstantPoolTypes.STRING;
import static mockit.asm.jvmConstants.ConstantPoolTypes.UTF8;

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

import mockit.asm.constantPool.ClassMemberItem;
import mockit.asm.constantPool.DoubleItem;
import mockit.asm.constantPool.DynamicItem;
import mockit.asm.constantPool.FloatItem;
import mockit.asm.constantPool.IntItem;
import mockit.asm.constantPool.Item;
import mockit.asm.constantPool.LongItem;
import mockit.asm.constantPool.MethodHandleItem;
import mockit.asm.constantPool.ModuleItem;
import mockit.asm.constantPool.NameAndTypeItem;
import mockit.asm.constantPool.PackageItem;
import mockit.asm.constantPool.StringItem;
import mockit.asm.util.MethodHandle;

import org.checkerframework.checker.index.qual.NonNegative;

/**
 * Copies the constant pool data from a {@link ClassReader} into a {@link ClassWriter}.
 */
final class ConstantPoolCopying {
    @NonNull
    private final ClassReader source;
    @NonNull
    private final ClassWriter destination;
    @NonNull
    private final Item[] newItems;
    @NonNegative
    private int itemIndex;

    ConstantPoolCopying(@NonNull ClassReader source, @NonNull ClassWriter destination) {
        this.source = source;
        this.destination = destination;
        newItems = new Item[source.items.length];
    }

    void copyPool(@Nullable BootstrapMethodsWriter bootstrapMethods) {
        if (bootstrapMethods != null) {
            bootstrapMethods.copyBootstrapMethods(source, newItems);
        }

        int[] items = source.items;
        int itemCount = items.length;

        for (itemIndex = 1; itemIndex < itemCount; itemIndex++) {
            source.codeIndex = items[itemIndex] - 1;
            int itemType = source.readSignedByte();

            Item newItem = copyItem(itemType);
            newItem.setNext(newItems);
        }

        int off = items[1] - 1;
        destination.getConstantPoolGeneration().copy(source.code, off, source.header, newItems);
    }

    @NonNull
    @SuppressWarnings("OverlyComplexMethod")
    private Item copyItem(int itemType) {
        switch (itemType) {
            case UTF8:
                return copyUTF8Item();
            case INTEGER:
                return copyIntItem();
            case FLOAT:
                return copyFloatItem();
            case LONG:
                return copyLongItem();
            case DOUBLE:
                return copyDoubleItem();
            case FIELD_REF:
            case METHOD_REF:
            case IMETHOD_REF:
                return copyFieldOrMethodReferenceItem(itemType);
            case NAME_TYPE:
                return copyNameAndTypeItem();
            case METHOD_HANDLE:
                return copyHandleItem();
            case DYNAMIC:
            case INVOKE_DYNAMIC:
                return copyDynamicItem(itemType);
            case STRING:
            case CLASS:
            case METHOD_TYPE:
                return copyNameReferenceItem(itemType);
            case MODULE:
                return copyModule();
            case PACKAGE:
                return copyPackage();
            default:
                throw new IllegalArgumentException("Unknown CP type, cannot copy: " + itemType);
        }
    }

    @NonNull
    private Item copyIntItem() {
        int itemValue = source.readInt();
        IntItem item = new IntItem(itemIndex);
        item.setValue(itemValue);
        return item;
    }

    @NonNull
    private Item copyLongItem() {
        long itemValue = source.readLong();
        LongItem item = new LongItem(itemIndex);
        item.setValue(itemValue);
        itemIndex++;
        return item;
    }

    @NonNull
    private Item copyFloatItem() {
        float itemValue = source.readFloat();
        FloatItem item = new FloatItem(itemIndex);
        item.set(itemValue);
        return item;
    }

    @NonNull
    private Item copyDoubleItem() {
        double itemValue = source.readDouble();
        DoubleItem item = new DoubleItem(itemIndex);
        item.set(itemValue);
        itemIndex++;
        return item;
    }

    @NonNull
    private Item copyUTF8Item() {
        String strVal = source.readString(itemIndex);
        return new StringItem(itemIndex, UTF8, strVal);
    }

    @NonNull
    private Item copyNameReferenceItem(int type) {
        String strVal = source.readNonnullUTF8();
        return new StringItem(itemIndex, type, strVal);
    }

    @NonNull
    private Item copyNameAndTypeItem() {
        String name = source.readNonnullUTF8();
        String type = source.readNonnullUTF8();

        NameAndTypeItem item = new NameAndTypeItem(itemIndex);
        item.set(name, type);
        return item;
    }

    @NonNull
    private Item copyFieldOrMethodReferenceItem(int type) {
        String classDesc = source.readNonnullClass();
        int nameCodeIndex = source.readItem();
        String methodName = source.readNonnullUTF8(nameCodeIndex);
        String methodDesc = source.readNonnullUTF8(nameCodeIndex + 2);

        ClassMemberItem item = new ClassMemberItem(itemIndex);
        item.set(type, classDesc, methodName, methodDesc);
        return item;
    }

    @NonNull
    private Item copyHandleItem() {
        int tag = source.readUnsignedByte();

        int fieldOrMethodRef = source.readItem();
        int nameCodeIndex = source.readItem(fieldOrMethodRef + 2);

        String classDesc = source.readNonnullClass(fieldOrMethodRef);
        String name = source.readNonnullUTF8(nameCodeIndex);
        String desc = source.readNonnullUTF8(nameCodeIndex + 2);

        MethodHandle handle = new MethodHandle(tag, classDesc, name, desc);
        MethodHandleItem item = new MethodHandleItem(itemIndex);
        item.set(handle);
        return item;
    }

    @NonNull
    private Item copyDynamicItem(int type) {
        int bsmIndex = source.readUnsignedShort();
        int nameCodeIndex = source.readItem();
        String name = source.readNonnullUTF8(nameCodeIndex);
        String desc = source.readNonnullUTF8(nameCodeIndex + 2);

        DynamicItem item = new DynamicItem(itemIndex);
        item.set(type, name, desc, bsmIndex);
        return item;
    }

    @NonNull
    private Item copyModule() {
        int nameIndex = source.readItem();
        String name = source.readNonnullUTF8(nameIndex);
        return new ModuleItem(itemIndex, MODULE, name);
    }

    @NonNull
    private Item copyPackage() {
        int nameIndex = source.readItem();
        String name = source.readNonnullUTF8(nameIndex);
        return new PackageItem(itemIndex, PACKAGE, name);
    }
}

1	/*
2	* MIT License
3	* Copyright (c) 2006-2025 JMockit developers
4	* See LICENSE file for full license text.
5	*/
6	package mockit.asm.classes;
7
8	import static mockit.asm.jvmConstants.ConstantPoolTypes.CLASS;
9	import static mockit.asm.jvmConstants.ConstantPoolTypes.DOUBLE;
10	import static mockit.asm.jvmConstants.ConstantPoolTypes.DYNAMIC;
11	import static mockit.asm.jvmConstants.ConstantPoolTypes.FIELD_REF;
12	import static mockit.asm.jvmConstants.ConstantPoolTypes.FLOAT;
13	import static mockit.asm.jvmConstants.ConstantPoolTypes.IMETHOD_REF;
14	import static mockit.asm.jvmConstants.ConstantPoolTypes.INTEGER;
15	import static mockit.asm.jvmConstants.ConstantPoolTypes.INVOKE_DYNAMIC;
16	import static mockit.asm.jvmConstants.ConstantPoolTypes.LONG;
17	import static mockit.asm.jvmConstants.ConstantPoolTypes.METHOD_HANDLE;
18	import static mockit.asm.jvmConstants.ConstantPoolTypes.METHOD_REF;
19	import static mockit.asm.jvmConstants.ConstantPoolTypes.METHOD_TYPE;
20	import static mockit.asm.jvmConstants.ConstantPoolTypes.MODULE;
21	import static mockit.asm.jvmConstants.ConstantPoolTypes.NAME_TYPE;
22	import static mockit.asm.jvmConstants.ConstantPoolTypes.PACKAGE;
23	import static mockit.asm.jvmConstants.ConstantPoolTypes.STRING;
24	import static mockit.asm.jvmConstants.ConstantPoolTypes.UTF8;
25
26	import edu.umd.cs.findbugs.annotations.NonNull;
27	import edu.umd.cs.findbugs.annotations.Nullable;
28
29	import mockit.asm.constantPool.ClassMemberItem;
30	import mockit.asm.constantPool.DoubleItem;
31	import mockit.asm.constantPool.DynamicItem;
32	import mockit.asm.constantPool.FloatItem;
33	import mockit.asm.constantPool.IntItem;
34	import mockit.asm.constantPool.Item;
35	import mockit.asm.constantPool.LongItem;
36	import mockit.asm.constantPool.MethodHandleItem;
37	import mockit.asm.constantPool.ModuleItem;
38	import mockit.asm.constantPool.NameAndTypeItem;
39	import mockit.asm.constantPool.PackageItem;
40	import mockit.asm.constantPool.StringItem;
41	import mockit.asm.util.MethodHandle;
42
43	import org.checkerframework.checker.index.qual.NonNegative;
44
45	/**
46	* Copies the constant pool data from a {@link ClassReader} into a {@link ClassWriter}.
47	*/
48	final class ConstantPoolCopying {
49	@NonNull
50	private final ClassReader source;
51	@NonNull
52	private final ClassWriter destination;
53	@NonNull
54	private final Item[] newItems;
55	@NonNegative
56	private int itemIndex;
57
58	ConstantPoolCopying(@NonNull ClassReader source, @NonNull ClassWriter destination) {	1✔
59	this.source = source;	1✔
60	this.destination = destination;	1✔
61	newItems = new Item[source.items.length];	1✔
62	}	1✔
63
64	void copyPool(@Nullable BootstrapMethodsWriter bootstrapMethods) {
65	if (bootstrapMethods != null) {	1✔
66	bootstrapMethods.copyBootstrapMethods(source, newItems);	1✔
67	}
68
69	int[] items = source.items;	1✔
70	int itemCount = items.length;	1✔
71
72	for (itemIndex = 1; itemIndex < itemCount; itemIndex++) {	1✔
73	source.codeIndex = items[itemIndex] - 1;	1✔
74	int itemType = source.readSignedByte();	1✔
75
76	Item newItem = copyItem(itemType);	1✔
77	newItem.setNext(newItems);	1✔
78	}
79
80	int off = items[1] - 1;	1✔
81	destination.getConstantPoolGeneration().copy(source.code, off, source.header, newItems);	1✔
82	}	1✔
83
84	@NonNull
85	@SuppressWarnings("OverlyComplexMethod")
86	private Item copyItem(int itemType) {
87	switch (itemType) {	1!
88	case UTF8:
89	return copyUTF8Item();	1✔
90	case INTEGER:
91	return copyIntItem();	1✔
92	case FLOAT:
93	return copyFloatItem();	1✔
94	case LONG:
95	return copyLongItem();	1✔
96	case DOUBLE:
97	return copyDoubleItem();	1✔
98	case FIELD_REF:
99	case METHOD_REF:
100	case IMETHOD_REF:
101	return copyFieldOrMethodReferenceItem(itemType);	1✔
102	case NAME_TYPE:
103	return copyNameAndTypeItem();	1✔
104	case METHOD_HANDLE:
105	return copyHandleItem();	1✔
106	case DYNAMIC:
107	case INVOKE_DYNAMIC:
108	return copyDynamicItem(itemType);	1✔
109	case STRING:
110	case CLASS:
111	case METHOD_TYPE:
112	return copyNameReferenceItem(itemType);	1✔
113	case MODULE:
114	return copyModule();	×
115	case PACKAGE:
116	return copyPackage();	×
117	default:
118	throw new IllegalArgumentException("Unknown CP type, cannot copy: " + itemType);	×
119	}
120	}
121
122	@NonNull
123	private Item copyIntItem() {
124	int itemValue = source.readInt();	1✔
125	IntItem item = new IntItem(itemIndex);	1✔
126	item.setValue(itemValue);	1✔
127	return item;	1✔
128	}
129
130	@NonNull
131	private Item copyLongItem() {
132	long itemValue = source.readLong();	1✔
133	LongItem item = new LongItem(itemIndex);	1✔
134	item.setValue(itemValue);	1✔
135	itemIndex++;	1✔
136	return item;	1✔
137	}
138
139	@NonNull
140	private Item copyFloatItem() {
141	float itemValue = source.readFloat();	1✔
142	FloatItem item = new FloatItem(itemIndex);	1✔
143	item.set(itemValue);	1✔
144	return item;	1✔
145	}
146
147	@NonNull
148	private Item copyDoubleItem() {
149	double itemValue = source.readDouble();	1✔
150	DoubleItem item = new DoubleItem(itemIndex);	1✔
151	item.set(itemValue);	1✔
152	itemIndex++;	1✔
153	return item;	1✔
154	}
155
156	@NonNull
157	private Item copyUTF8Item() {
158	String strVal = source.readString(itemIndex);	1✔
159	return new StringItem(itemIndex, UTF8, strVal);	1✔
160	}
161
162	@NonNull
163	private Item copyNameReferenceItem(int type) {
164	String strVal = source.readNonnullUTF8();	1✔
165	return new StringItem(itemIndex, type, strVal);	1✔
166	}
167
168	@NonNull
169	private Item copyNameAndTypeItem() {
170	String name = source.readNonnullUTF8();	1✔
171	String type = source.readNonnullUTF8();	1✔
172
173	NameAndTypeItem item = new NameAndTypeItem(itemIndex);	1✔
174	item.set(name, type);	1✔
175	return item;	1✔
176	}
177
178	@NonNull
179	private Item copyFieldOrMethodReferenceItem(int type) {
180	String classDesc = source.readNonnullClass();	1✔
181	int nameCodeIndex = source.readItem();	1✔
182	String methodName = source.readNonnullUTF8(nameCodeIndex);	1✔
183	String methodDesc = source.readNonnullUTF8(nameCodeIndex + 2);	1✔
184
185	ClassMemberItem item = new ClassMemberItem(itemIndex);	1✔
186	item.set(type, classDesc, methodName, methodDesc);	1✔
187	return item;	1✔
188	}
189
190	@NonNull
191	private Item copyHandleItem() {
192	int tag = source.readUnsignedByte();	1✔
193
194	int fieldOrMethodRef = source.readItem();	1✔
195	int nameCodeIndex = source.readItem(fieldOrMethodRef + 2);	1✔
196
197	String classDesc = source.readNonnullClass(fieldOrMethodRef);	1✔
198	String name = source.readNonnullUTF8(nameCodeIndex);	1✔
199	String desc = source.readNonnullUTF8(nameCodeIndex + 2);	1✔
200
201	MethodHandle handle = new MethodHandle(tag, classDesc, name, desc);	1✔
202	MethodHandleItem item = new MethodHandleItem(itemIndex);	1✔
203	item.set(handle);	1✔
204	return item;	1✔
205	}
206
207	@NonNull
208	private Item copyDynamicItem(int type) {
209	int bsmIndex = source.readUnsignedShort();	1✔
210	int nameCodeIndex = source.readItem();	1✔
211	String name = source.readNonnullUTF8(nameCodeIndex);	1✔
212	String desc = source.readNonnullUTF8(nameCodeIndex + 2);	1✔
213
214	DynamicItem item = new DynamicItem(itemIndex);	1✔
215	item.set(type, name, desc, bsmIndex);	1✔
216	return item;	1✔
217	}
218
219	@NonNull
220	private Item copyModule() {
221	int nameIndex = source.readItem();	×
222	String name = source.readNonnullUTF8(nameIndex);	×
223	return new ModuleItem(itemIndex, MODULE, name);	×
224	}
225
226	@NonNull
227	private Item copyPackage() {
228	int nameIndex = source.readItem();	×
229	String name = source.readNonnullUTF8(nameIndex);	×
230	return new PackageItem(itemIndex, PACKAGE, name);	×
231	}
232	}

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