leeonky / test-charm-java / 293

Committed 12 Sep 2025 04:43PM UTC coverage: 74.22% (-0.09%) from 74.312%

Build # 293

Build Type

push

circleci

Committed by

leeonky

Commit Message

create sub list from spec list in spec

Run Details

33 of 42 new or added lines in 8 files covered. (78.57%)

32 existing lines in 11 files now uncovered.

8234 of 11094 relevant lines covered (74.22%)

0.74 hits per line

Source File
Press 'n' to go to next uncovered line, 'b' for previous

97.44

/jfactory/src/main/java/com/github/leeonky/jfactory/CollectionExpression.java

package com.github.leeonky.jfactory;

import com.github.leeonky.util.CollectionHelper;
import com.github.leeonky.util.Property;

import java.util.ArrayList;
import java.util.LinkedHashMap;
import java.util.List;
import java.util.Map;
import java.util.stream.Collectors;

class CollectionExpression<P, E> extends Expression<P> {
    private final Map<Integer, Expression<E>> children = new LinkedHashMap<>();

    public CollectionExpression(Property<P> property, int index, Expression<E> elementExpression, boolean forQuery) {
        super(property, forQuery);
        children.put(index, elementExpression);
    }

    @Override
    protected boolean isPropertyMatch(Object collection) {
        if (collection == null)
            return false;
        List<Object> elements = CollectionHelper.toStream(collection).collect(Collectors.toList());
        return elements.size() > children.keySet().stream().reduce(Integer::max).orElse(0) &&
                children.entrySet().stream().allMatch(e -> isMatch(e.getValue(), elements.get(e.getKey())));
    }

    private boolean isMatch(Expression<E> expression, Object value) {
        return value != null && !expression.intently && expression.isPropertyMatch(value);
    }

    @Override
    @SuppressWarnings("unchecked")
    public Producer<?> buildProducer(JFactory jFactory, Producer<P> parent) {
        Producer value = parent.childOrDefault(property.getName());
        if (value instanceof CollectionProducer) {
            CollectionProducer<?, E> producer = (CollectionProducer<?, E>) value;
            groupByAdjustedPositiveAndNegativeIndexExpression(producer).forEach((index, expressions) ->
                    producer.changeChild(index.toString(), merge(expressions).buildProducer(jFactory, producer)));
            return producer;
        } else {
            children.forEach((index, expression) ->
                    value.changeChild(index.toString(), expression.buildProducer(jFactory, value)));
        }
        return value;
    }

    private Map<Integer, List<Expression<E>>> groupByAdjustedPositiveAndNegativeIndexExpression(
            CollectionProducer<?, E> collectionProducer) {
        Map<Integer, List<Expression<E>>> result = new LinkedHashMap<>();
        for (Map.Entry<Integer, Expression<E>> entry : children.entrySet()) {
            int index = entry.getKey();
            int addedProducerCount = collectionProducer.fillCollectionWithDefaultValue(index);
            if (index < 0) {
                index = collectionProducer.childrenCount() + index;
                result = adjustIndexByInserted(result, addedProducerCount);
            }
            result.computeIfAbsent(index, k -> new ArrayList<>()).add(entry.getValue());
        }
        return result;
    }

    private LinkedHashMap<Integer, List<Expression<E>>> adjustIndexByInserted(
            Map<Integer, List<Expression<E>>> result, int addedProducerCount) {
        return result.entrySet().stream().collect(LinkedHashMap::new,
                (m, e) -> m.put(e.getKey() + addedProducerCount, e.getValue()), LinkedHashMap::putAll);
    }

    @Override
    public Expression<P> mergeTo(Expression<P> newExpression) {
        return newExpression.mergeFrom(this);
    }

    @Override
    @SuppressWarnings("unchecked")
    protected Expression<P> mergeFrom(CollectionExpression<P, ?> origin) {
        children.forEach((index, expression) ->
                origin.children.put(index, origin.children.containsKey(index) ?
                        origin.children.get(index).mergeTo((Expression) expression) : (Expression) expression));
        return origin;
    }

    @Override
    protected Expression<P> setIntently(boolean intently) {
        if (intently)
            children.values().forEach(c -> c.setIntently(true));
        return super.setIntently(intently);
    }
}

1	package com.github.leeonky.jfactory;
2
3	import com.github.leeonky.util.CollectionHelper;
4	import com.github.leeonky.util.Property;
5
6	import java.util.ArrayList;
7	import java.util.LinkedHashMap;
8	import java.util.List;
9	import java.util.Map;
10	import java.util.stream.Collectors;
11
12	class CollectionExpression<P, E> extends Expression<P> {
13	private final Map<Integer, Expression<E>> children = new LinkedHashMap<>();	1✔
14
15	public CollectionExpression(Property<P> property, int index, Expression<E> elementExpression, boolean forQuery) {
16	super(property, forQuery);	1✔
17	children.put(index, elementExpression);	1✔
18	}	1✔
19
20	@Override
21	protected boolean isPropertyMatch(Object collection) {
22	if (collection == null)	1✔
UNCOV 23	return false;	×
24	List<Object> elements = CollectionHelper.toStream(collection).collect(Collectors.toList());	1✔
25	return elements.size() > children.keySet().stream().reduce(Integer::max).orElse(0) &&	1✔
26	children.entrySet().stream().allMatch(e -> isMatch(e.getValue(), elements.get(e.getKey())));	1✔
27	}
28
29	private boolean isMatch(Expression<E> expression, Object value) {
30	return value != null && !expression.intently && expression.isPropertyMatch(value);	1✔
31	}
32
33	@Override
34	@SuppressWarnings("unchecked")
35	public Producer<?> buildProducer(JFactory jFactory, Producer<P> parent) {
36	Producer value = parent.childOrDefault(property.getName());	1✔
37	if (value instanceof CollectionProducer) {	1✔
38	CollectionProducer<?, E> producer = (CollectionProducer<?, E>) value;	1✔
39	groupByAdjustedPositiveAndNegativeIndexExpression(producer).forEach((index, expressions) ->	1✔
40	producer.changeChild(index.toString(), merge(expressions).buildProducer(jFactory, producer)));	1✔
41	return producer;	1✔
42	} else {
43	children.forEach((index, expression) ->	1✔
44	value.changeChild(index.toString(), expression.buildProducer(jFactory, value)));	1✔
45	}
46	return value;	1✔
47	}
48
49	private Map<Integer, List<Expression<E>>> groupByAdjustedPositiveAndNegativeIndexExpression(
50	CollectionProducer<?, E> collectionProducer) {
51	Map<Integer, List<Expression<E>>> result = new LinkedHashMap<>();	1✔
52	for (Map.Entry<Integer, Expression<E>> entry : children.entrySet()) {	1✔
53	int index = entry.getKey();	1✔
54	int addedProducerCount = collectionProducer.fillCollectionWithDefaultValue(index);	1✔
55	if (index < 0) {	1✔
56	index = collectionProducer.childrenCount() + index;	1✔
57	result = adjustIndexByInserted(result, addedProducerCount);	1✔
58	}
59	result.computeIfAbsent(index, k -> new ArrayList<>()).add(entry.getValue());	1✔
60	}	1✔
61	return result;	1✔
62	}
63
64	private LinkedHashMap<Integer, List<Expression<E>>> adjustIndexByInserted(
65	Map<Integer, List<Expression<E>>> result, int addedProducerCount) {
66	return result.entrySet().stream().collect(LinkedHashMap::new,	1✔
67	(m, e) -> m.put(e.getKey() + addedProducerCount, e.getValue()), LinkedHashMap::putAll);	1✔
68	}
69
70	@Override
71	public Expression<P> mergeTo(Expression<P> newExpression) {
72	return newExpression.mergeFrom(this);	1✔
73	}
74
75	@Override
76	@SuppressWarnings("unchecked")
77	protected Expression<P> mergeFrom(CollectionExpression<P, ?> origin) {
78	children.forEach((index, expression) ->	1✔
79	origin.children.put(index, origin.children.containsKey(index) ?	1✔
80	origin.children.get(index).mergeTo((Expression) expression) : (Expression) expression));	1✔
81	return origin;	1✔
82	}
83
84	@Override
85	protected Expression<P> setIntently(boolean intently) {
86	if (intently)	1✔
87	children.values().forEach(c -> c.setIntently(true));	1✔
88	return super.setIntently(intently);	1✔
89	}
90	}

leeonky / test-charm-java / 293

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