leeonky / test-charm-java / 347

Committed 07 Oct 2025 09:20AM UTC coverage: 74.946% (+0.2%) from 74.7%

Build # 347

Build Type

push

circleci

Committed by

leeonky

Commit Message

raise error when dependent value changed

Run Details

23 of 23 new or added lines in 3 files covered. (100.0%)

20 existing lines in 6 files now uncovered.

8723 of 11639 relevant lines covered (74.95%)

0.75 hits per line

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

93.88

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

package com.github.leeonky.jfactory;

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

import static com.github.leeonky.jfactory.DefaultConsistency.LINK_COMPOSER;
import static com.github.leeonky.jfactory.DefaultConsistency.LINK_DECOMPOSER;
import static com.github.leeonky.jfactory.PropertyChain.propertyChain;
import static com.github.leeonky.util.Zipped.zip;
import static com.github.leeonky.util.function.Extension.notAllowParallelReduce;
import static java.util.Arrays.asList;
import static java.util.Collections.singletonList;
import static java.util.Optional.ofNullable;

class DefaultListConsistency<T, C extends Coordinate> implements ListConsistency<T, C> {
    final List<PropertyChain> listProperty;
    private final DefaultConsistency<T, C> consistency;
    final List<ListConsistencyItem<T>> items = new ArrayList<>();
    private Function<Coordinate, C> aligner = this::convert;

    private C convert(Coordinate e) {
        return e.convertTo(consistency.coordinateType());
    }

    private Function<C, Coordinate> inverseAligner = e -> e;

    DefaultListConsistency(List<String> listProperty, DefaultConsistency<T, C> consistency) {
        this.listProperty = listProperty.stream().map(PropertyChain::propertyChain).collect(Collectors.toList());
        this.consistency = consistency;
    }

    @Override
    @SuppressWarnings("unchecked")
    public ListConsistency<T, C> direct(String property) {
        return property(property).read((Function<Object, T>) LINK_COMPOSER).write((Function<T, Object>) LINK_DECOMPOSER);
    }

    @Override
    public <P> ListConsistency.LC1<T, P, C> property(String property) {
        ListConsistencyItem<T> listConsistencyItem = new ListConsistencyItem<>(singletonList(property));
        items.add(listConsistencyItem);
        return new DefaultListConsistency.LC1<>(this, listConsistencyItem);
    }

    @Override
    public <P1, P2> ListConsistency.LC2<T, P1, P2, C> properties(String property1, String property2) {
        ListConsistencyItem<T> listConsistencyItem = new ListConsistencyItem<>(asList(property1, property2));
        items.add(listConsistencyItem);
        return new DefaultListConsistency.LC2<>(this, listConsistencyItem);
    }

    @Override
    public <P1, P2, P3> LC3<T, P1, P2, P3, C> properties(String property1, String property2, String property3) {
        ListConsistencyItem<T> listConsistencyItem = new ListConsistencyItem<>(asList(property1, property2, property3));
        items.add(listConsistencyItem);
        return new LC3<>(this, listConsistencyItem);
    }

    Optional<PropertyChain> toProperty(C coordinate) {
        return ofNullable(inverseAligner.apply(coordinate)).map(co -> zip(listProperty, co.indexes()).stream().reduce(propertyChain(""),
                (p, z) -> p.concat(z.left()).concat(z.right().index()), notAllowParallelReduce()));
    }

    List<DefaultConsistency<T, C>> collectCoordinateAndProcess(ObjectProducer<?> producer, List<Index> baseIndex,
                                                               int l, PropertyChain baseProperty) {
        List<DefaultConsistency<T, C>> results = new ArrayList<>();
        PropertyChain list = baseProperty.concat(listProperty.get(l++));
        CollectionProducer<?, ?> collectionProducer = (CollectionProducer<?, ?>) producer.descendantForUpdate(list);
        for (int i = 0; i < collectionProducer.childrenCount(); i++) {
            Index index = new Index(collectionProducer.childrenCount(), i);
            List<Index> indexes = new ArrayList<>(baseIndex);
            indexes.add(index);
            if (listProperty.size() > l)
                results.addAll(collectCoordinateAndProcess(producer, indexes, l, list.concat(i)));
            else
                ofNullable(aligner.apply(new Coordinate(indexes))).ifPresent(c ->
                        results.add(consistency.populateConsistencyWithList(c)));
        }
        return results;
    }

    public void normalize(Function<Coordinate, C> aligner,
                          Function<C, Coordinate> inverseAligner) {
        this.aligner = aligner;
        this.inverseAligner = inverseAligner;
    }
}

class DecorateListConsistency<T, C extends Coordinate> implements ListConsistency<T, C> {
    private final ListConsistency<T, C> delegate;

    public DecorateListConsistency(ListConsistency<T, C> delegate) {
        this.delegate = delegate;
    }

    @Override
    public ListConsistency<T, C> direct(String property) {
        return delegate.direct(property);
    }

    @Override
    public <P> ListConsistency.LC1<T, P, C> property(String property) {
        return delegate.property(property);
    }

    @Override
    public <P1, P2> ListConsistency.LC2<T, P1, P2, C> properties(String property1, String property2) {
        return delegate.properties(property1, property2);
    }

    @Override
    public <P1, P2, P3> LC3<T, P1, P2, P3, C> properties(String property1, String property2, String property3) {
        return delegate.properties(property1, property2, property3);
    }
}

class MultiPropertyListConsistency<T, M extends MultiPropertyListConsistency<T, M, C>, C extends Coordinate>
        extends DecorateListConsistency<T, C> {
    final ListConsistencyItem<T> last;

    MultiPropertyListConsistency(ListConsistency<T, C> delegate, ListConsistencyItem<T> last) {
        super(delegate);
        this.last = last;
    }

    @SuppressWarnings("unchecked")
    public M read(Function<Object[], T> composer) {
        last.setComposer(new ComposerWrapper<>(composer, composer));
        return (M) this;
    }

    @SuppressWarnings("unchecked")
    public M write(Function<T, Object[]> decomposer) {
        last.setDecomposer(new DecomposerWrapper<>(decomposer, decomposer));
        return (M) this;
    }
}

1	package com.github.leeonky.jfactory;
2
3	import java.util.ArrayList;
4	import java.util.List;
5	import java.util.Optional;
6	import java.util.function.Function;
7	import java.util.stream.Collectors;
8
9	import static com.github.leeonky.jfactory.DefaultConsistency.LINK_COMPOSER;
10	import static com.github.leeonky.jfactory.DefaultConsistency.LINK_DECOMPOSER;
11	import static com.github.leeonky.jfactory.PropertyChain.propertyChain;
12	import static com.github.leeonky.util.Zipped.zip;
13	import static com.github.leeonky.util.function.Extension.notAllowParallelReduce;
14	import static java.util.Arrays.asList;
15	import static java.util.Collections.singletonList;
16	import static java.util.Optional.ofNullable;
17
18	class DefaultListConsistency<T, C extends Coordinate> implements ListConsistency<T, C> {
19	final List<PropertyChain> listProperty;
20	private final DefaultConsistency<T, C> consistency;
21	final List<ListConsistencyItem<T>> items = new ArrayList<>();	1✔
22	private Function<Coordinate, C> aligner = this::convert;	1✔
23
24	private C convert(Coordinate e) {
25	return e.convertTo(consistency.coordinateType());	1✔
26	}
27
28	private Function<C, Coordinate> inverseAligner = e -> e;	1✔
29
30	DefaultListConsistency(List<String> listProperty, DefaultConsistency<T, C> consistency) {	1✔
31	this.listProperty = listProperty.stream().map(PropertyChain::propertyChain).collect(Collectors.toList());	1✔
32	this.consistency = consistency;	1✔
33	}	1✔
34
35	@Override
36	@SuppressWarnings("unchecked")
37	public ListConsistency<T, C> direct(String property) {
38	return property(property).read((Function<Object, T>) LINK_COMPOSER).write((Function<T, Object>) LINK_DECOMPOSER);	1✔
39	}
40
41	@Override
42	public <P> ListConsistency.LC1<T, P, C> property(String property) {
43	ListConsistencyItem<T> listConsistencyItem = new ListConsistencyItem<>(singletonList(property));	1✔
44	items.add(listConsistencyItem);	1✔
45	return new DefaultListConsistency.LC1<>(this, listConsistencyItem);	1✔
46	}
47
48	@Override
49	public <P1, P2> ListConsistency.LC2<T, P1, P2, C> properties(String property1, String property2) {
50	ListConsistencyItem<T> listConsistencyItem = new ListConsistencyItem<>(asList(property1, property2));	1✔
51	items.add(listConsistencyItem);	1✔
52	return new DefaultListConsistency.LC2<>(this, listConsistencyItem);	1✔
53	}
54
55	@Override
56	public <P1, P2, P3> LC3<T, P1, P2, P3, C> properties(String property1, String property2, String property3) {
57	ListConsistencyItem<T> listConsistencyItem = new ListConsistencyItem<>(asList(property1, property2, property3));	1✔
58	items.add(listConsistencyItem);	1✔
59	return new LC3<>(this, listConsistencyItem);	1✔
60	}
61
62	Optional<PropertyChain> toProperty(C coordinate) {
63	return ofNullable(inverseAligner.apply(coordinate)).map(co -> zip(listProperty, co.indexes()).stream().reduce(propertyChain(""),	1✔
64	(p, z) -> p.concat(z.left()).concat(z.right().index()), notAllowParallelReduce()));	1✔
65	}
66
67	List<DefaultConsistency<T, C>> collectCoordinateAndProcess(ObjectProducer<?> producer, List<Index> baseIndex,
68	int l, PropertyChain baseProperty) {
69	List<DefaultConsistency<T, C>> results = new ArrayList<>();	1✔
70	PropertyChain list = baseProperty.concat(listProperty.get(l++));	1✔
71	CollectionProducer<?, ?> collectionProducer = (CollectionProducer<?, ?>) producer.descendantForUpdate(list);	1✔
72	for (int i = 0; i < collectionProducer.childrenCount(); i++) {	1✔
73	Index index = new Index(collectionProducer.childrenCount(), i);	1✔
74	List<Index> indexes = new ArrayList<>(baseIndex);	1✔
75	indexes.add(index);	1✔
76	if (listProperty.size() > l)	1✔
77	results.addAll(collectCoordinateAndProcess(producer, indexes, l, list.concat(i)));	1✔
78	else
79	ofNullable(aligner.apply(new Coordinate(indexes))).ifPresent(c ->	1✔
80	results.add(consistency.populateConsistencyWithList(c)));	1✔
81	}
82	return results;	1✔
83	}
84
85	public void normalize(Function<Coordinate, C> aligner,
86	Function<C, Coordinate> inverseAligner) {
87	this.aligner = aligner;	1✔
88	this.inverseAligner = inverseAligner;	1✔
89	}	1✔
90	}
91
92	class DecorateListConsistency<T, C extends Coordinate> implements ListConsistency<T, C> {
93	private final ListConsistency<T, C> delegate;
94
95	public DecorateListConsistency(ListConsistency<T, C> delegate) {	1✔
96	this.delegate = delegate;	1✔
97	}	1✔
98
99	@Override
100	public ListConsistency<T, C> direct(String property) {
101	return delegate.direct(property);	1✔
102	}
103
104	@Override
105	public <P> ListConsistency.LC1<T, P, C> property(String property) {
UNCOV 106	return delegate.property(property);	×
107	}
108
109	@Override
110	public <P1, P2> ListConsistency.LC2<T, P1, P2, C> properties(String property1, String property2) {
UNCOV 111	return delegate.properties(property1, property2);	×
112	}
113
114	@Override
115	public <P1, P2, P3> LC3<T, P1, P2, P3, C> properties(String property1, String property2, String property3) {
UNCOV 116	return delegate.properties(property1, property2, property3);	×
117	}
118	}
119
120	class MultiPropertyListConsistency<T, M extends MultiPropertyListConsistency<T, M, C>, C extends Coordinate>
121	extends DecorateListConsistency<T, C> {
122	final ListConsistencyItem<T> last;
123
124	MultiPropertyListConsistency(ListConsistency<T, C> delegate, ListConsistencyItem<T> last) {
125	super(delegate);	1✔
126	this.last = last;	1✔
127	}	1✔
128
129	@SuppressWarnings("unchecked")
130	public M read(Function<Object[], T> composer) {
131	last.setComposer(new ComposerWrapper<>(composer, composer));	1✔
132	return (M) this;	1✔
133	}
134
135	@SuppressWarnings("unchecked")
136	public M write(Function<T, Object[]> decomposer) {
137	last.setDecomposer(new DecomposerWrapper<>(decomposer, decomposer));	1✔
138	return (M) this;	1✔
139	}
140	}

leeonky / test-charm-java / 347

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