leeonky / test-charm-java / 356

Committed 08 Oct 2025 01:39PM UTC coverage: 75.141% (+5.1%) from 70.03%

Build # 356

Build Type

push

circleci

Committed by

leeonky

Commit Message

Update version

Run Details

8817 of 11734 relevant lines covered (75.14%)

0.75 hits per line

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

93.75

/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 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 -> co.join(listProperty));
    }

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

leeonky / test-charm-java / 356

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