leeonky / test-charm-java / 338

Committed 05 Oct 2025 04:05PM UTC coverage: 74.667% (+0.06%) from 74.611%

Build # 338

Build Type

push

circleci

Committed by

leeonky

Commit Message

Some index mapping in list consistency

Run Details

4 of 4 new or added lines in 2 files covered. (100.0%)

23 existing lines in 3 files now uncovered.

8627 of 11554 relevant lines covered (74.67%)

0.75 hits per line

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

86.99

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

package com.github.leeonky.jfactory;

import com.github.leeonky.util.BeanClass;
import com.github.leeonky.util.Sneaky;

import java.util.*;
import java.util.function.Function;
import java.util.function.Predicate;

import static com.github.leeonky.jfactory.ConsistencyItem.guessCustomerPositionStackTrace;
import static com.github.leeonky.jfactory.PropertyChain.propertyChain;
import static java.util.Arrays.asList;
import static java.util.Collections.singletonList;
import static java.util.stream.Collectors.toCollection;
import static java.util.stream.Collectors.toList;

class DefaultConsistency<T, C extends Coordinate> implements Consistency<T, C> {
    final List<ConsistencyItem<T>> items = new ArrayList<>();
    final List<DefaultListConsistency<T, C>> list = new ArrayList<>();
    private final BeanClass<T> type;
    private final BeanClass<C> coordinateType;
    final List<StackTraceElement> locations = new ArrayList<>();

    static final Function<Object, Object> LINK_COMPOSER = s -> s;
    static final Function<Object, Object> LINK_DECOMPOSER = s -> s;

    DefaultConsistency(Class<T> type, Class<C> cType) {
        this(BeanClass.create(type), BeanClass.create(cType));
    }

    DefaultConsistency(BeanClass<T> type, BeanClass<C> cType) {
        this(type, cType, singletonList(guessCustomerPositionStackTrace()));
    }

    DefaultConsistency(BeanClass<T> type, BeanClass<C> cType, List<StackTraceElement> locations) {
        this.type = type;
        coordinateType = cType;
        this.locations.addAll(locations);
    }

    @Override
    public BeanClass<T> type() {
        return type;
    }

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

    @Override
    public <P> C1<T, P, C> property(String property) {
        ConsistencyItem<T> item = new ConsistencyItem<>(singletonList(propertyChain(property)), this);
        items.add(item);
        return new C1<>(this, item);
    }

    @Override
    public <P1, P2> C2<T, P1, P2, C> properties(String property1, String property2) {
        ConsistencyItem<T> item = new ConsistencyItem<>(asList(propertyChain(property1), propertyChain(property2)), this);
        items.add(item);
        return new C2<>(this, item);
    }

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

    @Override
    public CN<T, C> properties(String... properties) {
        ConsistencyItem<T> item = new ConsistencyItem<>(Arrays.stream(properties).map(PropertyChain::propertyChain).collect(toList()), this);
        items.add(item);
        return new CN<>(this, item);
    }

    boolean merge(DefaultConsistency<?, ?> another) {
        if (items.stream().anyMatch(item -> another.items.stream().anyMatch(item::same))) {
            another.items.forEach(item -> items.add(Sneaky.cast(item)));
            return true;
        }
        return false;
    }

    @Override
    public String toString() {
        StringBuilder builder = new StringBuilder();
        builder.append("  ").append(type().getName()).append(":");
        for (StackTraceElement location : locations) {
            builder.append("\n    ").append(location.getClassName()).append(".").append(location.getMethodName())
                    .append("(").append(location.getFileName()).append(":").append(location.getLineNumber()).append(")");
        }

        for (ConsistencyItem<T> item : items) {
            builder.append("\n    - ").append(item);
        }
        return builder.toString();
    }

    DefaultConsistency<T, C> absoluteProperty(PropertyChain base) {
        DefaultConsistency<T, C> absolute = new DefaultConsistency<>(type(), coordinateType(), locations);
        items.forEach(item -> absolute.items.add(item.absoluteProperty(base)));
        return absolute;
    }

    Resolver resolver(ObjectProducer<?> root) {
        return new Resolver(root);
    }

    @Override
    public ListConsistencyBuilder.D1<T, C> list(String property) {
        DefaultListConsistency<T, C> listConsistency = new DefaultListConsistency<>(singletonList(property), this);
        list.add(listConsistency);
        return new ListConsistencyBuilder.D1<>(this, listConsistency);
    }

    @Override
    public ListConsistencyBuilder<T, C> list(String property1, String property2) {
        DefaultListConsistency<T, C> listConsistency = new DefaultListConsistency<>(asList(property1, property2), this);
        list.add(listConsistency);
        return new ListConsistencyBuilder<>(this, listConsistency);
    }

    @Deprecated
    DefaultConsistency<T, C> processListConsistency(ObjectProducer<?> producer) {
        list.forEach(listConsistency -> listConsistency.populateConsistencies(producer, propertyChain("")));
        return this;
    }

    public List<DefaultConsistency<T, C>> populateListConsistencies(ObjectProducer<?> producer) {
        if (list.isEmpty())
            return singletonList(this);
        List<DefaultConsistency<T, C>> consistencies = new ArrayList<>();
        for (DefaultListConsistency<T, C> indexSource : list) {
            consistencies.addAll(indexSource.collectCoordinateAndProcess(producer, new ArrayList<>(), 0, propertyChain("")));
        }
        return consistencies;
    }

    DefaultConsistency<T, C> populateConsistencyWithList(C coordinate) {
        DefaultConsistency<T, C> newConsistency = new DefaultConsistency<>(type(), coordinateType(), locations);
        for (DefaultListConsistency<T, C> listConsistency : list) {
            listConsistency.toProperty(coordinate).ifPresent(elementProperty -> {
                for (ListConsistencyItem<T> item : listConsistency.items)
                    item.populateConsistency(elementProperty, newConsistency);
            });
        }
        for (ConsistencyItem<T> item : items) {
            newConsistency.items.add(item.copy(newConsistency));
        }
        return newConsistency;
    }

    public BeanClass<C> coordinateType() {
        return coordinateType;
    }

    interface Identity {
        default Object identity() {
            return this;
        }

        default boolean same(Identity another) {
            return another != null && identity() == another.identity();
        }

        StackTraceElement getLocation();
    }

    interface Composer<T> extends Function<Object[], T>, Identity {
    }

    interface Decomposer<T> extends Function<T, Object[]>, Identity {
    }

    class Resolver {
        private final Set<ConsistencyItem<T>.Resolver> providers;
        private final Set<ConsistencyItem<T>.Resolver> consumers;

        Resolver(ObjectProducer<?> root) {
            List<ConsistencyItem<T>.Resolver> itemResolvers = items.stream().map(i -> i.resolver(root, this)).collect(toList());
            providers = itemResolvers.stream().filter(ConsistencyItem.Resolver::hasComposer).collect(toCollection(LinkedHashSet::new));
            consumers = itemResolvers.stream().filter(ConsistencyItem.Resolver::hasDecomposer).collect(toCollection(LinkedHashSet::new));
        }

        Set<PropertyChain> resolve(ConsistencyItem<T>.Resolver provider) {
            Set<PropertyChain> resolved = new HashSet<>();
            for (ConsistencyItem<T>.Resolver consumer : consumers)
                if (consumer != provider)
                    resolved.addAll(consumer.resolve(provider));
            return resolved;
        }

        Optional<ConsistencyItem<T>.Resolver> searchProvider(Predicate<ConsistencyItem<?>.Resolver> condition) {
            return providers.stream().filter(condition).min(this::onlyComposerFirstOrder);
        }

        ConsistencyItem<T>.Resolver defaultProvider() {
            return providers.stream().min(this::onlyComposerFirstOrder).get();
        }

        private int onlyComposerFirstOrder(ConsistencyItem<T>.Resolver r1, ConsistencyItem<T>.Resolver r2) {
            if (!r1.hasDecomposer())
                return -1;
            return !r2.hasDecomposer() ? 1 : 0;
        }

        Optional<ConsistencyItem<T>.Resolver> propertyRelated(PropertyChain property) {
            return providers.stream().filter(p -> p.containsProperty(property)).findFirst();
        }
    }
}

class DecorateConsistency<T, C extends Coordinate> implements Consistency<T, C> {
    private final Consistency<T, C> delegate;

    DecorateConsistency(Consistency<T, C> delegate) {
        this.delegate = delegate;
    }

    @Override
    public BeanClass<T> type() {
        return delegate.type();
    }

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

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

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

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

    @Override
    public CN<T, C> properties(String... properties) {
        return delegate.properties(properties);
    }

    @Override
    public ListConsistencyBuilder.D1<T, C> list(String property) {
        return delegate.list(property);
    }

    @Override
    public ListConsistencyBuilder<T, C> list(String property1, String property2) {
        return delegate.list(property1, property2);
    }
}

class IdentityAction implements DefaultConsistency.Identity {
    protected final Object identity;
    private final StackTraceElement location;

    public IdentityAction(Object identity) {
        this.identity = Objects.requireNonNull(identity);
        location = guessCustomerPositionStackTrace();
    }

    @Override
    public Object identity() {
        return identity;
    }

    @Override
    public StackTraceElement getLocation() {
        return location;
    }
}

class ComposerWrapper<T> extends IdentityAction implements DefaultConsistency.Composer<T> {
    private final Function<Object[], T> action;

    ComposerWrapper(Function<Object[], T> action, Object identity) {
        super(identity);
        this.action = Objects.requireNonNull(action);
    }

    @Override
    public T apply(Object[] objects) {
        return action.apply(objects);
    }
}

class DecomposerWrapper<T> extends IdentityAction implements DefaultConsistency.Decomposer<T> {
    private final Function<T, Object[]> action;

    DecomposerWrapper(Function<T, Object[]> action, Object identity) {
        super(identity);
        this.action = Objects.requireNonNull(action);
    }

    @Override
    public Object[] apply(T t) {
        return action.apply(t);
    }
}

class MultiPropertyConsistency<T, M extends MultiPropertyConsistency<T, M, C>, C extends Coordinate>
        extends DecorateConsistency<T, C> {
    final ConsistencyItem<T> lastItem;

    MultiPropertyConsistency(Consistency<T, C> origin, ConsistencyItem<T> lastItem) {
        super(origin);
        this.lastItem = lastItem;
    }

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

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

1	package com.github.leeonky.jfactory;
2
3	import com.github.leeonky.util.BeanClass;
4	import com.github.leeonky.util.Sneaky;
5
6	import java.util.*;
7	import java.util.function.Function;
8	import java.util.function.Predicate;
9
10	import static com.github.leeonky.jfactory.ConsistencyItem.guessCustomerPositionStackTrace;
11	import static com.github.leeonky.jfactory.PropertyChain.propertyChain;
12	import static java.util.Arrays.asList;
13	import static java.util.Collections.singletonList;
14	import static java.util.stream.Collectors.toCollection;
15	import static java.util.stream.Collectors.toList;
16
17	class DefaultConsistency<T, C extends Coordinate> implements Consistency<T, C> {
18	final List<ConsistencyItem<T>> items = new ArrayList<>();	1✔
19	final List<DefaultListConsistency<T, C>> list = new ArrayList<>();	1✔
20	private final BeanClass<T> type;
21	private final BeanClass<C> coordinateType;
22	final List<StackTraceElement> locations = new ArrayList<>();	1✔
23
24	static final Function<Object, Object> LINK_COMPOSER = s -> s;	1✔
25	static final Function<Object, Object> LINK_DECOMPOSER = s -> s;	1✔
26
27	DefaultConsistency(Class<T> type, Class<C> cType) {
28	this(BeanClass.create(type), BeanClass.create(cType));	1✔
29	}	1✔
30
31	DefaultConsistency(BeanClass<T> type, BeanClass<C> cType) {
32	this(type, cType, singletonList(guessCustomerPositionStackTrace()));	1✔
33	}	1✔
34
35	DefaultConsistency(BeanClass<T> type, BeanClass<C> cType, List<StackTraceElement> locations) {	1✔
36	this.type = type;	1✔
37	coordinateType = cType;	1✔
38	this.locations.addAll(locations);	1✔
39	}	1✔
40
41	@Override
42	public BeanClass<T> type() {
43	return type;	1✔
44	}
45
46	@Override
47	@SuppressWarnings("unchecked")
48	public Consistency<T, C> direct(String property) {
49	return property(property).read((Function<Object, T>) LINK_COMPOSER).write((Function<T, Object>) LINK_DECOMPOSER);	1✔
50	}
51
52	@Override
53	public <P> C1<T, P, C> property(String property) {
54	ConsistencyItem<T> item = new ConsistencyItem<>(singletonList(propertyChain(property)), this);	1✔
55	items.add(item);	1✔
56	return new C1<>(this, item);	1✔
57	}
58
59	@Override
60	public <P1, P2> C2<T, P1, P2, C> properties(String property1, String property2) {
61	ConsistencyItem<T> item = new ConsistencyItem<>(asList(propertyChain(property1), propertyChain(property2)), this);	1✔
62	items.add(item);	1✔
63	return new C2<>(this, item);	1✔
64	}
65
66	@Override
67	public <P1, P2, P3> C3<T, P1, P2, P3, C> properties(String property1, String property2, String property3) {
68	ConsistencyItem<T> item = new ConsistencyItem<>(asList(propertyChain(property1), propertyChain(property2), propertyChain(property3)), this);	1✔
69	items.add(item);	1✔
70	return new C3<>(this, item);	1✔
71	}
72
73	@Override
74	public CN<T, C> properties(String... properties) {
75	ConsistencyItem<T> item = new ConsistencyItem<>(Arrays.stream(properties).map(PropertyChain::propertyChain).collect(toList()), this);	1✔
76	items.add(item);	1✔
77	return new CN<>(this, item);	1✔
78	}
79
80	boolean merge(DefaultConsistency<?, ?> another) {
81	if (items.stream().anyMatch(item -> another.items.stream().anyMatch(item::same))) {	1✔
82	another.items.forEach(item -> items.add(Sneaky.cast(item)));	1✔
83	return true;	1✔
84	}
85	return false;	1✔
86	}
87
88	@Override
89	public String toString() {
90	StringBuilder builder = new StringBuilder();	×
91	builder.append(" ").append(type().getName()).append(":");	×
92	for (StackTraceElement location : locations) {	×
93	builder.append("\n ").append(location.getClassName()).append(".").append(location.getMethodName())	×
UNCOV 94	.append("(").append(location.getFileName()).append(":").append(location.getLineNumber()).append(")");	×
UNCOV 95	}	×
96
UNCOV 97	for (ConsistencyItem<T> item : items) {	×
UNCOV 98	builder.append("\n - ").append(item);	×
UNCOV 99	}	×
UNCOV 100	return builder.toString();	×
101	}
102
103	DefaultConsistency<T, C> absoluteProperty(PropertyChain base) {
104	DefaultConsistency<T, C> absolute = new DefaultConsistency<>(type(), coordinateType(), locations);	1✔
105	items.forEach(item -> absolute.items.add(item.absoluteProperty(base)));	1✔
106	return absolute;	1✔
107	}
108
109	Resolver resolver(ObjectProducer<?> root) {
110	return new Resolver(root);	1✔
111	}
112
113	@Override
114	public ListConsistencyBuilder.D1<T, C> list(String property) {
115	DefaultListConsistency<T, C> listConsistency = new DefaultListConsistency<>(singletonList(property), this);	1✔
116	list.add(listConsistency);	1✔
117	return new ListConsistencyBuilder.D1<>(this, listConsistency);	1✔
118	}
119
120	@Override
121	public ListConsistencyBuilder<T, C> list(String property1, String property2) {
122	DefaultListConsistency<T, C> listConsistency = new DefaultListConsistency<>(asList(property1, property2), this);	1✔
123	list.add(listConsistency);	1✔
124	return new ListConsistencyBuilder<>(this, listConsistency);	1✔
125	}
126
127	@Deprecated
128	DefaultConsistency<T, C> processListConsistency(ObjectProducer<?> producer) {
UNCOV 129	list.forEach(listConsistency -> listConsistency.populateConsistencies(producer, propertyChain("")));	×
UNCOV 130	return this;	×
131	}
132
133	public List<DefaultConsistency<T, C>> populateListConsistencies(ObjectProducer<?> producer) {
134	if (list.isEmpty())	1✔
135	return singletonList(this);	1✔
136	List<DefaultConsistency<T, C>> consistencies = new ArrayList<>();	1✔
137	for (DefaultListConsistency<T, C> indexSource : list) {	1✔
138	consistencies.addAll(indexSource.collectCoordinateAndProcess(producer, new ArrayList<>(), 0, propertyChain("")));	1✔
139	}	1✔
140	return consistencies;	1✔
141	}
142
143	DefaultConsistency<T, C> populateConsistencyWithList(C coordinate) {
144	DefaultConsistency<T, C> newConsistency = new DefaultConsistency<>(type(), coordinateType(), locations);	1✔
145	for (DefaultListConsistency<T, C> listConsistency : list) {	1✔
146	listConsistency.toProperty(coordinate).ifPresent(elementProperty -> {	1✔
147	for (ListConsistencyItem<T> item : listConsistency.items)	1✔
148	item.populateConsistency(elementProperty, newConsistency);	1✔
149	});	1✔
150	}	1✔
151	for (ConsistencyItem<T> item : items) {	1✔
152	newConsistency.items.add(item.copy(newConsistency));	1✔
153	}	1✔
154	return newConsistency;	1✔
155	}
156
157	public BeanClass<C> coordinateType() {
158	return coordinateType;	1✔
159	}
160
161	interface Identity {
162	default Object identity() {
UNCOV 163	return this;	×
164	}
165
166	default boolean same(Identity another) {
167	return another != null && identity() == another.identity();	1✔
168	}
169
170	StackTraceElement getLocation();
171	}
172
173	interface Composer<T> extends Function<Object[], T>, Identity {
174	}
175
176	interface Decomposer<T> extends Function<T, Object[]>, Identity {
177	}
178
179	class Resolver {
180	private final Set<ConsistencyItem<T>.Resolver> providers;
181	private final Set<ConsistencyItem<T>.Resolver> consumers;
182
183	Resolver(ObjectProducer<?> root) {	1✔
184	List<ConsistencyItem<T>.Resolver> itemResolvers = items.stream().map(i -> i.resolver(root, this)).collect(toList());	1✔
185	providers = itemResolvers.stream().filter(ConsistencyItem.Resolver::hasComposer).collect(toCollection(LinkedHashSet::new));	1✔
186	consumers = itemResolvers.stream().filter(ConsistencyItem.Resolver::hasDecomposer).collect(toCollection(LinkedHashSet::new));	1✔
187	}	1✔
188
189	Set<PropertyChain> resolve(ConsistencyItem<T>.Resolver provider) {
190	Set<PropertyChain> resolved = new HashSet<>();	1✔
191	for (ConsistencyItem<T>.Resolver consumer : consumers)	1✔
192	if (consumer != provider)	1✔
193	resolved.addAll(consumer.resolve(provider));	1✔
194	return resolved;	1✔
195	}
196
197	Optional<ConsistencyItem<T>.Resolver> searchProvider(Predicate<ConsistencyItem<?>.Resolver> condition) {
198	return providers.stream().filter(condition).min(this::onlyComposerFirstOrder);	1✔
199	}
200
201	ConsistencyItem<T>.Resolver defaultProvider() {
202	return providers.stream().min(this::onlyComposerFirstOrder).get();	1✔
203	}
204
205	private int onlyComposerFirstOrder(ConsistencyItem<T>.Resolver r1, ConsistencyItem<T>.Resolver r2) {
206	if (!r1.hasDecomposer())	1✔
207	return -1;	1✔
208	return !r2.hasDecomposer() ? 1 : 0;	1✔
209	}
210
211	Optional<ConsistencyItem<T>.Resolver> propertyRelated(PropertyChain property) {
212	return providers.stream().filter(p -> p.containsProperty(property)).findFirst();	1✔
213	}
214	}
215	}
216
217	class DecorateConsistency<T, C extends Coordinate> implements Consistency<T, C> {
218	private final Consistency<T, C> delegate;
219
220	DecorateConsistency(Consistency<T, C> delegate) {	1✔
221	this.delegate = delegate;	1✔
222	}	1✔
223
224	@Override
225	public BeanClass<T> type() {
UNCOV 226	return delegate.type();	×
227	}
228
229	@Override
230	public Consistency<T, C> direct(String property) {
231	return delegate.direct(property);	1✔
232	}
233
234	@Override
235	public <P> C1<T, P, C> property(String property) {
236	return delegate.property(property);	1✔
237	}
238
239	@Override
240	public <P1, P2> C2<T, P1, P2, C> properties(String property1, String property2) {
241	return delegate.properties(property1, property2);	1✔
242	}
243
244	@Override
245	public <P1, P2, P3> C3<T, P1, P2, P3, C> properties(String property1, String property2, String property3) {
246	return delegate.properties(property1, property2, property3);	1✔
247	}
248
249	@Override
250	public CN<T, C> properties(String... properties) {
251	return delegate.properties(properties);	1✔
252	}
253
254	@Override
255	public ListConsistencyBuilder.D1<T, C> list(String property) {
UNCOV 256	return delegate.list(property);	×
257	}
258
259	@Override
260	public ListConsistencyBuilder<T, C> list(String property1, String property2) {
UNCOV 261	return delegate.list(property1, property2);	×
262	}
263	}
264
265	class IdentityAction implements DefaultConsistency.Identity {
266	protected final Object identity;
267	private final StackTraceElement location;
268
269	public IdentityAction(Object identity) {	1✔
270	this.identity = Objects.requireNonNull(identity);	1✔
271	location = guessCustomerPositionStackTrace();	1✔
272	}	1✔
273
274	@Override
275	public Object identity() {
276	return identity;	1✔
277	}
278
279	@Override
280	public StackTraceElement getLocation() {
281	return location;	1✔
282	}
283	}
284
285	class ComposerWrapper<T> extends IdentityAction implements DefaultConsistency.Composer<T> {
286	private final Function<Object[], T> action;
287
288	ComposerWrapper(Function<Object[], T> action, Object identity) {
289	super(identity);	1✔
290	this.action = Objects.requireNonNull(action);	1✔
291	}	1✔
292
293	@Override
294	public T apply(Object[] objects) {
295	return action.apply(objects);	1✔
296	}
297	}
298
299	class DecomposerWrapper<T> extends IdentityAction implements DefaultConsistency.Decomposer<T> {
300	private final Function<T, Object[]> action;
301
302	DecomposerWrapper(Function<T, Object[]> action, Object identity) {
303	super(identity);	1✔
304	this.action = Objects.requireNonNull(action);	1✔
305	}	1✔
306
307	@Override
308	public Object[] apply(T t) {
309	return action.apply(t);	1✔
310	}
311	}
312
313	class MultiPropertyConsistency<T, M extends MultiPropertyConsistency<T, M, C>, C extends Coordinate>
314	extends DecorateConsistency<T, C> {
315	final ConsistencyItem<T> lastItem;
316
317	MultiPropertyConsistency(Consistency<T, C> origin, ConsistencyItem<T> lastItem) {
318	super(origin);	1✔
319	this.lastItem = lastItem;	1✔
320	}	1✔
321
322	@SuppressWarnings("unchecked")
323	public M read(Function<Object[], T> composer) {
324	lastItem.setComposer(new ComposerWrapper<>(composer, composer));	1✔
325	return (M) this;	1✔
326	}
327
328	@SuppressWarnings("unchecked")
329	public M write(Function<T, Object[]> decomposer) {
330	lastItem.setDecomposer(new DecomposerWrapper<>(decomposer, decomposer));	1✔
331	return (M) this;	1✔
332	}
333	}

leeonky / test-charm-java / 338

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