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

93.04

/main/src/main/java/mockit/internal/expectations/invocation/MultiValuedConversion.java

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

import static mockit.internal.util.Utilities.JAVA8;

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

import java.lang.reflect.Array;
import java.util.ArrayList;
import java.util.Collection;
import java.util.Iterator;
import java.util.LinkedHashMap;
import java.util.LinkedHashSet;
import java.util.List;
import java.util.ListIterator;
import java.util.Map;
import java.util.Set;
import java.util.SortedMap;
import java.util.SortedSet;
import java.util.TreeMap;
import java.util.TreeSet;
import java.util.stream.Stream;

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

final class MultiValuedConversion {
    @NonNull
    private final InvocationResults invocationResults;
    @NonNull
    private final Class<?> returnType;
    @NonNull
    private final Object valueToReturn;

    MultiValuedConversion(@NonNull InvocationResults invocationResults, @NonNull Class<?> returnType,
            @NonNull Object valueToReturn) {
        this.invocationResults = invocationResults;
        this.returnType = returnType;
        this.valueToReturn = valueToReturn;
    }

    void addMultiValuedResultBasedOnTheReturnType(boolean valueIsArray) {
        if (returnType == void.class) {
            addMultiValuedResult(valueIsArray);
        } else if (returnType == Object.class) {
            invocationResults.addReturnValueResult(valueToReturn);
        } else if (valueIsArray && addCollectionOrMapWithElementsFromArray()) {
            // Do nothing
        } else if (hasReturnOfDifferentType()) {
            addMultiValuedResult(valueIsArray);
        } else {
            invocationResults.addReturnValueResult(valueToReturn);
        }
    }

    private void addMultiValuedResult(boolean valueIsArray) {
        if (valueIsArray) {
            invocationResults.addResults(valueToReturn);
        } else if (valueToReturn instanceof Iterable<?>) {
            if (JAVA8 && valueToReturn instanceof Collection && returnType.isAssignableFrom(Stream.class)) {
                invocationResults.addReturnValueResult(((Collection<?>) valueToReturn).stream());
            } else {
                invocationResults.addResults((Iterable<?>) valueToReturn);
            }
        } else {
            invocationResults.addDeferredResults((Iterator<?>) valueToReturn);
        }
    }

    private boolean hasReturnOfDifferentType() {
        return !returnType.isArray() && !Iterable.class.isAssignableFrom(returnType)
                && !Iterator.class.isAssignableFrom(returnType)
                && !returnType.isAssignableFrom(valueToReturn.getClass());
    }

    private boolean addCollectionOrMapWithElementsFromArray() {
        @NonNegative
        int n = Array.getLength(valueToReturn);
        Object values = null;

        if (returnType.isAssignableFrom(ListIterator.class)) {
            List<Object> list = new ArrayList<>(n);
            addArrayElements(list, n);
            values = list.listIterator();
        } else if (returnType.isAssignableFrom(List.class)) {
            values = addArrayElements(new ArrayList<>(n), n);
        } else if (returnType.isAssignableFrom(Set.class)) {
            values = addArrayElements(new LinkedHashSet<>(n), n);
        } else if (returnType.isAssignableFrom(SortedSet.class)) {
            values = addArrayElements(new TreeSet<>(), n);
        } else if (returnType.isAssignableFrom(Map.class)) {
            values = addArrayElements(new LinkedHashMap<>(n), n);
        } else if (returnType.isAssignableFrom(SortedMap.class)) {
            values = addArrayElements(new TreeMap<>(), n);
        } else if (JAVA8 && returnType.isAssignableFrom(Stream.class)) {
            values = addArrayElements(new ArrayList<>(n), n).stream();
        }

        if (values != null) {
            invocationResults.addReturnValue(values);
            return true;
        }

        return false;
    }

    @NonNull
    private Collection<?> addArrayElements(@NonNull Collection<Object> values, @NonNegative int elementCount) {
        for (int i = 0; i < elementCount; i++) {
            Object element = Array.get(valueToReturn, i);
            values.add(element);
        }

        return values;
    }

    @Nullable
    private Object addArrayElements(@NonNull Map<Object, Object> values, @NonNegative int elementPairCount) {
        for (int i = 0; i < elementPairCount; i++) {
            Object keyAndValue = Array.get(valueToReturn, i);

            if (keyAndValue == null || !keyAndValue.getClass().isArray()) {
                return null;
            }

            Object key = Array.get(keyAndValue, 0);
            Object element = Array.getLength(keyAndValue) > 1 ? Array.get(keyAndValue, 1) : null;
            values.put(key, element);
        }

        return values;
    }
}

1	/*
2	* MIT License
3	* Copyright (c) 2006-2025 JMockit developers
4	* See LICENSE file for full license text.
5	*/
6	package mockit.internal.expectations.invocation;
7
8	import static mockit.internal.util.Utilities.JAVA8;
9
10	import edu.umd.cs.findbugs.annotations.NonNull;
11	import edu.umd.cs.findbugs.annotations.Nullable;
12
13	import java.lang.reflect.Array;
14	import java.util.ArrayList;
15	import java.util.Collection;
16	import java.util.Iterator;
17	import java.util.LinkedHashMap;
18	import java.util.LinkedHashSet;
19	import java.util.List;
20	import java.util.ListIterator;
21	import java.util.Map;
22	import java.util.Set;
23	import java.util.SortedMap;
24	import java.util.SortedSet;
25	import java.util.TreeMap;
26	import java.util.TreeSet;
27	import java.util.stream.Stream;
28
29	import org.checkerframework.checker.index.qual.NonNegative;
30
31	final class MultiValuedConversion {
32	@NonNull
33	private final InvocationResults invocationResults;
34	@NonNull
35	private final Class<?> returnType;
36	@NonNull
37	private final Object valueToReturn;
38
39	MultiValuedConversion(@NonNull InvocationResults invocationResults, @NonNull Class<?> returnType,
40	@NonNull Object valueToReturn) {	1✔
41	this.invocationResults = invocationResults;	1✔
42	this.returnType = returnType;	1✔
43	this.valueToReturn = valueToReturn;	1✔
44	}	1✔
45
46	void addMultiValuedResultBasedOnTheReturnType(boolean valueIsArray) {
47	if (returnType == void.class) {	1✔
48	addMultiValuedResult(valueIsArray);	1✔
49	} else if (returnType == Object.class) {	1!
50	invocationResults.addReturnValueResult(valueToReturn);	×
51	} else if (valueIsArray && addCollectionOrMapWithElementsFromArray()) {	1✔
52	// Do nothing
53	} else if (hasReturnOfDifferentType()) {	1✔
54	addMultiValuedResult(valueIsArray);	1✔
55	} else {
56	invocationResults.addReturnValueResult(valueToReturn);	1✔
57	}
58	}	1✔
59
60	private void addMultiValuedResult(boolean valueIsArray) {
61	if (valueIsArray) {	1✔
62	invocationResults.addResults(valueToReturn);	1✔
63	} else if (valueToReturn instanceof Iterable<?>) {	1✔
64	if (JAVA8 && valueToReturn instanceof Collection && returnType.isAssignableFrom(Stream.class)) {	1!
65	invocationResults.addReturnValueResult(((Collection<?>) valueToReturn).stream());	1✔
66	} else {
67	invocationResults.addResults((Iterable<?>) valueToReturn);	1✔
68	}
69	} else {
70	invocationResults.addDeferredResults((Iterator<?>) valueToReturn);	1✔
71	}
72	}	1✔
73
74	private boolean hasReturnOfDifferentType() {
75	return !returnType.isArray() && !Iterable.class.isAssignableFrom(returnType)	1✔
76	&& !Iterator.class.isAssignableFrom(returnType)	1✔
77	&& !returnType.isAssignableFrom(valueToReturn.getClass());	1!
78	}
79
80	private boolean addCollectionOrMapWithElementsFromArray() {
81	@NonNegative
82	int n = Array.getLength(valueToReturn);	1✔
83	Object values = null;	1✔
84
85	if (returnType.isAssignableFrom(ListIterator.class)) {	1✔
86	List<Object> list = new ArrayList<>(n);	1✔
87	addArrayElements(list, n);	1✔
88	values = list.listIterator();	1✔
89	} else if (returnType.isAssignableFrom(List.class)) {	1✔
90	values = addArrayElements(new ArrayList<>(n), n);	1✔
91	} else if (returnType.isAssignableFrom(Set.class)) {	1✔
92	values = addArrayElements(new LinkedHashSet<>(n), n);	1✔
93	} else if (returnType.isAssignableFrom(SortedSet.class)) {	1✔
94	values = addArrayElements(new TreeSet<>(), n);	1✔
95	} else if (returnType.isAssignableFrom(Map.class)) {	1✔
96	values = addArrayElements(new LinkedHashMap<>(n), n);	1✔
97	} else if (returnType.isAssignableFrom(SortedMap.class)) {	1✔
98	values = addArrayElements(new TreeMap<>(), n);	1✔
99	} else if (JAVA8 && returnType.isAssignableFrom(Stream.class)) {	1!
100	values = addArrayElements(new ArrayList<>(n), n).stream();	1✔
101	}
102
103	if (values != null) {	1✔
104	invocationResults.addReturnValue(values);	1✔
105	return true;	1✔
106	}
107
108	return false;	1✔
109	}
110
111	@NonNull
112	private Collection<?> addArrayElements(@NonNull Collection<Object> values, @NonNegative int elementCount) {
113	for (int i = 0; i < elementCount; i++) {	1✔
114	Object element = Array.get(valueToReturn, i);	1✔
115	values.add(element);	1✔
116	}
117
118	return values;	1✔
119	}
120
121	@Nullable
122	private Object addArrayElements(@NonNull Map<Object, Object> values, @NonNegative int elementPairCount) {
123	for (int i = 0; i < elementPairCount; i++) {	1✔
124	Object keyAndValue = Array.get(valueToReturn, i);	1✔
125
126	if (keyAndValue == null \|\| !keyAndValue.getClass().isArray()) {	1!
127	return null;	×
128	}
129
130	Object key = Array.get(keyAndValue, 0);	1✔
131	Object element = Array.getLength(keyAndValue) > 1 ? Array.get(keyAndValue, 1) : null;	1✔
132	values.put(key, element);	1✔
133	}
134
135	return values;	1✔
136	}
137	}

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