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)

Coverage Stats

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.3

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

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

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

import java.util.ArrayList;
import java.util.IdentityHashMap;
import java.util.Iterator;
import java.util.List;
import java.util.Map;
import java.util.Map.Entry;
import java.util.regex.Pattern;

import mockit.internal.util.ClassLoad;

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

/**
 * Holds state associated with fake class containing {@linkplain mockit.Mock annotated fakes}.
 */
public final class FakeStates {
    private static final Pattern SPACE = Pattern.compile(" ");

    /**
     * For each fake instance and each <code>@Mock</code> method containing the <code>Invocation</code> parameter, a
     * runtime state will be kept here.
     */
    @NonNull
    private final Map<Object, List<FakeState>> fakesToFakeStates;
    @NonNull
    private final Map<Object, List<FakeState>> startupFakesToFakeStates;

    public FakeStates() {
        startupFakesToFakeStates = new IdentityHashMap<>(2);
        fakesToFakeStates = new IdentityHashMap<>(8);
    }

    void addStartupFakeAndItsFakeStates(@NonNull Object fake, @NonNull List<FakeState> fakeStates) {
        startupFakesToFakeStates.put(fake, fakeStates);
    }

    void addFakeAndItsFakeStates(@NonNull Object fake, @NonNull List<FakeState> fakeStates) {
        fakesToFakeStates.put(fake, fakeStates);
    }

    public void copyFakeStates(@NonNull Object previousFake, @NonNull Object newFake) {
        List<FakeState> fakeStates = fakesToFakeStates.get(previousFake);

        if (fakeStates != null) {
            List<FakeState> copiedFakeStates = new ArrayList<>(fakeStates.size());

            for (FakeState fakeState : fakeStates) {
                copiedFakeStates.add(new FakeState(fakeState));
            }

            fakesToFakeStates.put(newFake, copiedFakeStates);
        }
    }

    public void removeClassState(@NonNull Class<?> redefinedClass,
            @Nullable String internalNameForOneOrMoreFakeClasses) {
        removeFakeStates(redefinedClass);

        if (internalNameForOneOrMoreFakeClasses != null) {
            if (internalNameForOneOrMoreFakeClasses.indexOf(' ') < 0) {
                removeFakeStates(internalNameForOneOrMoreFakeClasses);
            } else {
                String[] fakeClassesInternalNames = SPACE.split(internalNameForOneOrMoreFakeClasses);

                for (String fakeClassInternalName : fakeClassesInternalNames) {
                    removeFakeStates(fakeClassInternalName);
                }
            }
        }
    }

    private void removeFakeStates(@NonNull Class<?> redefinedClass) {
        Iterator<List<FakeState>> itr = fakesToFakeStates.values().iterator();

        while (itr.hasNext()) {
            List<FakeState> fakeStates = itr.next();
            FakeState fakeState = fakeStates.get(0);

            if (fakeState.getRealClass() == redefinedClass) {
                fakeStates.clear();
                itr.remove();
            }
        }
    }

    private void removeFakeStates(@NonNull String fakeClassInternalName) {
        Class<?> fakeClass = ClassLoad.loadClass(fakeClassInternalName.replace('/', '.'));
        Iterator<Entry<Object, List<FakeState>>> itr = fakesToFakeStates.entrySet().iterator();

        while (itr.hasNext()) {
            Entry<Object, List<FakeState>> fakeAndFakeStates = itr.next();
            Object fake = fakeAndFakeStates.getKey();

            if (fake.getClass() == fakeClass) {
                itr.remove();
            }
        }
    }

    public boolean updateFakeState(@NonNull Object fake, @NonNegative int fakeStateIndex) {
        FakeState fakeState = getFakeState(fake, fakeStateIndex);
        return fakeState.update();
    }

    @NonNull
    FakeState getFakeState(@NonNull Object fake, @NonNegative int fakeStateIndex) {
        List<FakeState> fakeStates = startupFakesToFakeStates.get(fake);

        if (fakeStates == null) {
            fakeStates = fakesToFakeStates.get(fake);
        }

        FakeState fakeState = fakeStates.get(fakeStateIndex);
        assert fakeState != null;
        return fakeState;
    }
}

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 edu.umd.cs.findbugs.annotations.NonNull;
9	import edu.umd.cs.findbugs.annotations.Nullable;
10
11	import java.util.ArrayList;
12	import java.util.IdentityHashMap;
13	import java.util.Iterator;
14	import java.util.List;
15	import java.util.Map;
16	import java.util.Map.Entry;
17	import java.util.regex.Pattern;
18
19	import mockit.internal.util.ClassLoad;
20
21	import org.checkerframework.checker.index.qual.NonNegative;
22
23	/**
24	* Holds state associated with fake class containing {@linkplain mockit.Mock annotated fakes}.
25	*/
26	public final class FakeStates {
27	private static final Pattern SPACE = Pattern.compile(" ");	1✔
28
29	/**
30	* For each fake instance and each <code>@Mock</code> method containing the <code>Invocation</code> parameter, a
31	* runtime state will be kept here.
32	*/
33	@NonNull
34	private final Map<Object, List<FakeState>> fakesToFakeStates;
35	@NonNull
36	private final Map<Object, List<FakeState>> startupFakesToFakeStates;
37
38	public FakeStates() {	1✔
39	startupFakesToFakeStates = new IdentityHashMap<>(2);	1✔
40	fakesToFakeStates = new IdentityHashMap<>(8);	1✔
41	}	1✔
42
43	void addStartupFakeAndItsFakeStates(@NonNull Object fake, @NonNull List<FakeState> fakeStates) {
44	startupFakesToFakeStates.put(fake, fakeStates);	1✔
45	}	1✔
46
47	void addFakeAndItsFakeStates(@NonNull Object fake, @NonNull List<FakeState> fakeStates) {
48	fakesToFakeStates.put(fake, fakeStates);	1✔
49	}	1✔
50
51	public void copyFakeStates(@NonNull Object previousFake, @NonNull Object newFake) {
52	List<FakeState> fakeStates = fakesToFakeStates.get(previousFake);	1✔
53
54	if (fakeStates != null) {	1!
55	List<FakeState> copiedFakeStates = new ArrayList<>(fakeStates.size());	×
56
57	for (FakeState fakeState : fakeStates) {	×
58	copiedFakeStates.add(new FakeState(fakeState));	×
59	}	×
60
61	fakesToFakeStates.put(newFake, copiedFakeStates);	×
62	}
63	}	1✔
64
65	public void removeClassState(@NonNull Class<?> redefinedClass,
66	@Nullable String internalNameForOneOrMoreFakeClasses) {
67	removeFakeStates(redefinedClass);	1✔
68
69	if (internalNameForOneOrMoreFakeClasses != null) {	1✔
70	if (internalNameForOneOrMoreFakeClasses.indexOf(' ') < 0) {	1✔
71	removeFakeStates(internalNameForOneOrMoreFakeClasses);	1✔
72	} else {
73	String[] fakeClassesInternalNames = SPACE.split(internalNameForOneOrMoreFakeClasses);	1✔
74
75	for (String fakeClassInternalName : fakeClassesInternalNames) {	1✔
76	removeFakeStates(fakeClassInternalName);	1✔
77	}
78	}
79	}
80	}	1✔
81
82	private void removeFakeStates(@NonNull Class<?> redefinedClass) {
83	Iterator<List<FakeState>> itr = fakesToFakeStates.values().iterator();	1✔
84
85	while (itr.hasNext()) {	1✔
86	List<FakeState> fakeStates = itr.next();	1✔
87	FakeState fakeState = fakeStates.get(0);	1✔
88
89	if (fakeState.getRealClass() == redefinedClass) {	1✔
90	fakeStates.clear();	1✔
91	itr.remove();	1✔
92	}
93	}	1✔
94	}	1✔
95
96	private void removeFakeStates(@NonNull String fakeClassInternalName) {
97	Class<?> fakeClass = ClassLoad.loadClass(fakeClassInternalName.replace('/', '.'));	1✔
98	Iterator<Entry<Object, List<FakeState>>> itr = fakesToFakeStates.entrySet().iterator();	1✔
99
100	while (itr.hasNext()) {	1✔
101	Entry<Object, List<FakeState>> fakeAndFakeStates = itr.next();	1✔
102	Object fake = fakeAndFakeStates.getKey();	1✔
103
104	if (fake.getClass() == fakeClass) {	1✔
105	itr.remove();	1✔
106	}
107	}	1✔
108	}	1✔
109
110	public boolean updateFakeState(@NonNull Object fake, @NonNegative int fakeStateIndex) {
111	FakeState fakeState = getFakeState(fake, fakeStateIndex);	1✔
112	return fakeState.update();	1✔
113	}
114
115	@NonNull
116	FakeState getFakeState(@NonNull Object fake, @NonNegative int fakeStateIndex) {
117	List<FakeState> fakeStates = startupFakesToFakeStates.get(fake);	1✔
118
119	if (fakeStates == null) {	1✔
120	fakeStates = fakesToFakeStates.get(fake);	1✔
121	}
122
123	FakeState fakeState = fakeStates.get(fakeStateIndex);	1✔
124	assert fakeState != null;	1!
125	return fakeState;	1✔
126	}
127	}

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