leeonky / test-charm-java / 323

Committed 30 Sep 2025 05:15PM UTC coverage: 74.637% (+0.1%) from 74.512%

Build # 323

Build Type

push

circleci

Committed by

leeonky

Commit Message

Use descendantForRead in consistent provider

Run Details

16 of 17 new or added lines in 4 files covered. (94.12%)

29 existing lines in 7 files now uncovered.

8531 of 11430 relevant lines covered (74.64%)

0.75 hits per line

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

97.73

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

package com.github.leeonky.jfactory;

import com.github.leeonky.jfactory.DefaultValueFactories.DefaultTypeFactory;
import com.github.leeonky.util.BeanClass;
import com.github.leeonky.util.PropertyWriter;

import java.util.ArrayList;
import java.util.List;
import java.util.Optional;
import java.util.function.Function;

import static com.github.leeonky.util.function.Extension.getFirstPresent;
import static java.lang.Integer.max;
import static java.lang.Integer.parseInt;
import static java.util.Optional.ofNullable;
import static java.util.stream.Collectors.toList;
import static java.util.stream.IntStream.range;

class CollectionProducer<T, C> extends Producer<C> {
    private final List<Producer<?>> children = new ArrayList<>();
    private final BeanClass<T> parentType;
    private final CollectionInstance<T> collection;
    private final FactorySet factorySet;
    private Function<PropertyWriter<C>, Producer<?>> elementDefaultProducerFactory = any -> null;

    public CollectionProducer(BeanClass<T> parentType, BeanClass<C> collectionType,
                              SubInstance<T> instance, FactorySet factorySet) {
        super(collectionType);
        this.parentType = parentType;
        collection = instance.inCollection();
        this.factorySet = factorySet;
    }

    public void changeElementDefaultProducerFactory(Function<PropertyWriter<C>, Producer<?>> factory) {
        elementDefaultProducerFactory = factory;
    }

    @Override
    @SuppressWarnings("unchecked")
    protected C produce() {
        return (C) getType().createCollection(children.stream().map(Producer::getValue).collect(toList()));
    }

    @Override
    public Optional<Producer<?>> getChild(String property) {
        int index = parseInt(property);
        index = transformNegativeIndex(index);
        return ofNullable(index < children.size() ? children.get(index) : null);
    }

    @Override
    protected void setChild(String property, Producer<?> producer) {
        int index = parseInt(property);
        fillCollectionWithDefaultValue(index);
        children.set(transformNegativeIndex(index), producer);
    }

    private int transformNegativeIndex(int index) {
        return index < 0 ? children.size() + index : index;
    }

    public int fillCollectionWithDefaultValue(int index) {
        int changed = 0;
        if (index >= 0) {
            for (int i = children.size(); i <= index; i++, changed++)
                children.add(newDefaultElementProducer(getType().getPropertyWriter(String.valueOf(i))));
        } else {
            int count = max(children.size(), -index) - children.size();
            for (int i = 0; i < count; i++, changed++)
                children.add(i, newDefaultElementProducer(getType().getPropertyWriter(String.valueOf(i))));
        }
        return changed;
    }

    public Producer<?> newDefaultElementProducer(PropertyWriter<C> propertyWriter) {
        return getFirstPresent(() -> ofNullable(elementDefaultProducerFactory.apply(propertyWriter)),
                () -> newDefaultValueProducer(propertyWriter)).orElseGet(() ->
                new DefaultValueFactoryProducer<>(parentType, new DefaultTypeFactory<>(getType().getElementType()),
                        collection.element(parseInt(propertyWriter.getName()))));
    }

    @Override
    public Producer<?> childForUpdate(String property) {
        int index = parseInt(property);
        fillCollectionWithDefaultValue(index);
        return children.get(transformNegativeIndex(index));
    }

    @Override
    public Producer<?> childForRead(String property) {
        return getChild(property).orElse(PlaceHolderProducer.PLACE_HOLDER);
    }

    @Override
    protected void collectConsistent(ObjectProducer<?> root, PropertyChain base) {
        range(0, children.size()).forEach(i ->
                children.get(i).collectConsistent(root, base.concat(String.valueOf(i))));
    }

    @Override
    public Optional<Producer<?>> newDefaultValueProducer(PropertyWriter<?> property) {
        return factorySet.queryDefaultValueFactory(getType().getElementType()).map(builder ->
                new DefaultValueFactoryProducer<>(parentType, builder, collection.element(parseInt(property.getName()))));
    }

    @Override
    protected <R> void setupAssociation(String association, RootInstance<R> instance, ListPersistable cachedChildren) {
        children.stream().filter(ObjectProducer.class::isInstance).map(ObjectProducer.class::cast).forEach(objectProducer ->
                objectProducer.setupAssociation(association, instance, cachedChildren));
    }

    public int childrenCount() {
        return children.size();
    }

    @Override
    protected boolean isFixed() {
        return children.stream().anyMatch(Producer::isFixed);
    }
}

1	package com.github.leeonky.jfactory;
2
3	import com.github.leeonky.jfactory.DefaultValueFactories.DefaultTypeFactory;
4	import com.github.leeonky.util.BeanClass;
5	import com.github.leeonky.util.PropertyWriter;
6
7	import java.util.ArrayList;
8	import java.util.List;
9	import java.util.Optional;
10	import java.util.function.Function;
11
12	import static com.github.leeonky.util.function.Extension.getFirstPresent;
13	import static java.lang.Integer.max;
14	import static java.lang.Integer.parseInt;
15	import static java.util.Optional.ofNullable;
16	import static java.util.stream.Collectors.toList;
17	import static java.util.stream.IntStream.range;
18
19	class CollectionProducer<T, C> extends Producer<C> {
20	private final List<Producer<?>> children = new ArrayList<>();	1✔
21	private final BeanClass<T> parentType;
22	private final CollectionInstance<T> collection;
23	private final FactorySet factorySet;
24	private Function<PropertyWriter<C>, Producer<?>> elementDefaultProducerFactory = any -> null;	1✔
25
26	public CollectionProducer(BeanClass<T> parentType, BeanClass<C> collectionType,
27	SubInstance<T> instance, FactorySet factorySet) {
28	super(collectionType);	1✔
29	this.parentType = parentType;	1✔
30	collection = instance.inCollection();	1✔
31	this.factorySet = factorySet;	1✔
32	}	1✔
33
34	public void changeElementDefaultProducerFactory(Function<PropertyWriter<C>, Producer<?>> factory) {
35	elementDefaultProducerFactory = factory;	1✔
36	}	1✔
37
38	@Override
39	@SuppressWarnings("unchecked")
40	protected C produce() {
41	return (C) getType().createCollection(children.stream().map(Producer::getValue).collect(toList()));	1✔
42	}
43
44	@Override
45	public Optional<Producer<?>> getChild(String property) {
46	int index = parseInt(property);	1✔
47	index = transformNegativeIndex(index);	1✔
48	return ofNullable(index < children.size() ? children.get(index) : null);	1✔
49	}
50
51	@Override
52	protected void setChild(String property, Producer<?> producer) {
53	int index = parseInt(property);	1✔
54	fillCollectionWithDefaultValue(index);	1✔
55	children.set(transformNegativeIndex(index), producer);	1✔
56	}	1✔
57
58	private int transformNegativeIndex(int index) {
59	return index < 0 ? children.size() + index : index;	1✔
60	}
61
62	public int fillCollectionWithDefaultValue(int index) {
63	int changed = 0;	1✔
64	if (index >= 0) {	1✔
65	for (int i = children.size(); i <= index; i++, changed++)	1✔
66	children.add(newDefaultElementProducer(getType().getPropertyWriter(String.valueOf(i))));	1✔
67	} else {
68	int count = max(children.size(), -index) - children.size();	1✔
69	for (int i = 0; i < count; i++, changed++)	1✔
70	children.add(i, newDefaultElementProducer(getType().getPropertyWriter(String.valueOf(i))));	1✔
71	}
72	return changed;	1✔
73	}
74
75	public Producer<?> newDefaultElementProducer(PropertyWriter<C> propertyWriter) {
76	return getFirstPresent(() -> ofNullable(elementDefaultProducerFactory.apply(propertyWriter)),	1✔
77	() -> newDefaultValueProducer(propertyWriter)).orElseGet(() ->	1✔
78	new DefaultValueFactoryProducer<>(parentType, new DefaultTypeFactory<>(getType().getElementType()),	1✔
79	collection.element(parseInt(propertyWriter.getName()))));	1✔
80	}
81
82	@Override
83	public Producer<?> childForUpdate(String property) {
84	int index = parseInt(property);	1✔
85	fillCollectionWithDefaultValue(index);	1✔
86	return children.get(transformNegativeIndex(index));	1✔
87	}
88
89	@Override
90	public Producer<?> childForRead(String property) {
91	return getChild(property).orElse(PlaceHolderProducer.PLACE_HOLDER);	1✔
92	}
93
94	@Override
95	protected void collectConsistent(ObjectProducer<?> root, PropertyChain base) {
96	range(0, children.size()).forEach(i ->	1✔
97	children.get(i).collectConsistent(root, base.concat(String.valueOf(i))));	1✔
98	}	1✔
99
100	@Override
101	public Optional<Producer<?>> newDefaultValueProducer(PropertyWriter<?> property) {
102	return factorySet.queryDefaultValueFactory(getType().getElementType()).map(builder ->	1✔
103	new DefaultValueFactoryProducer<>(parentType, builder, collection.element(parseInt(property.getName()))));	1✔
104	}
105
106	@Override
107	protected <R> void setupAssociation(String association, RootInstance<R> instance, ListPersistable cachedChildren) {
108	children.stream().filter(ObjectProducer.class::isInstance).map(ObjectProducer.class::cast).forEach(objectProducer ->	1✔
109	objectProducer.setupAssociation(association, instance, cachedChildren));	1✔
110	}	1✔
111
112	public int childrenCount() {
113	return children.size();	1✔
114	}
115
116	@Override
117	protected boolean isFixed() {
UNCOV 118	return children.stream().anyMatch(Producer::isFixed);	×
119	}
120	}

leeonky / test-charm-java / 323

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