hazendaz / jmockit1 / 422

Committed 30 Oct 2025 09:23PM UTC coverage: 72.22% (+0.02%) from 72.198%

Build # 422

Build Type

push

github

Committed by

hazendaz

Commit Message

Combine catches

Run Details

5674 of 8356 branches covered (67.9%)

Branch coverage included in aggregate %.

0 of 1 new or added line in 1 file covered. (0.0%)

52 existing lines in 8 files now uncovered.

11929 of 16018 relevant lines covered (74.47%)

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

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

hazendaz / jmockit1 / 422

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