leeonky / test-charm-java / 320

Committed 28 Sep 2025 03:56PM UTC coverage: 74.512% (+0.07%) from 74.442%

Build # 320

Build Type

push

circleci

Committed by

leeonky

Commit Message

one list one property

Run Details

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

13 existing lines in 7 files now uncovered.

8466 of 11362 relevant lines covered (74.51%)

0.75 hits per line

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

86.27

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

package com.github.leeonky.jfactory;

import com.github.leeonky.util.BeanClass;

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

import static com.github.leeonky.jfactory.ConsistencyItem.guessCustomerPositionStackTrace;
import static com.github.leeonky.util.Sneaky.cast;
import static java.util.Collections.singletonList;
import static java.util.stream.Collectors.toCollection;
import static java.util.stream.Collectors.toList;

class DefaultConsistency<T> extends AbstractConsistency<T> {
    private final List<ConsistencyItem<T>> items = new ArrayList<>();
    private final List<DefaultListConsistency<T>> list = new ArrayList<>();

    private final BeanClass<T> type;
    private final List<StackTraceElement> locations = new ArrayList<>();

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

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

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

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

    @Override
    Consistency<T> link(ConsistencyItem<T> item) {
        items.add(item);
        return this;
    }

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

    public String info() {
        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(")");
        }
        return builder.toString();
    }

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

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

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

    public DefaultConsistency<T> processListConsistency(ObjectProducer<?> producer) {
        for (DefaultListConsistency<T> listConsistency : list)
            listConsistency.resolveToItems(producer);
        return this;
    }

    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();
        }
    }
}

1	package com.github.leeonky.jfactory;
2
3	import com.github.leeonky.util.BeanClass;
4
5	import java.util.*;
6	import java.util.function.Predicate;
7
8	import static com.github.leeonky.jfactory.ConsistencyItem.guessCustomerPositionStackTrace;
9	import static com.github.leeonky.util.Sneaky.cast;
10	import static java.util.Collections.singletonList;
11	import static java.util.stream.Collectors.toCollection;
12	import static java.util.stream.Collectors.toList;
13
14	class DefaultConsistency<T> extends AbstractConsistency<T> {
15	private final List<ConsistencyItem<T>> items = new ArrayList<>();	1✔
16	private final List<DefaultListConsistency<T>> list = new ArrayList<>();	1✔
17
18	private final BeanClass<T> type;
19	private final List<StackTraceElement> locations = new ArrayList<>();	1✔
20
21	DefaultConsistency(Class<T> type) {
22	this(BeanClass.create(type));	1✔
23	}	1✔
24
25	DefaultConsistency(BeanClass<T> type) {
26	this(type, singletonList(guessCustomerPositionStackTrace()));	1✔
27	}	1✔
28
29	DefaultConsistency(BeanClass<T> type, List<StackTraceElement> locations) {	1✔
30	this.type = type;	1✔
31	this.locations.addAll(locations);	1✔
32	}	1✔
33
34	@Override
35	BeanClass<T> type() {
36	return type;	1✔
37	}
38
39	@Override
40	Consistency<T> link(ConsistencyItem<T> item) {
41	items.add(item);	1✔
42	return this;	1✔
43	}
44
45	public boolean merge(DefaultConsistency<?> another) {
46	if (items.stream().anyMatch(item -> another.items.stream().anyMatch(item::same))) {	1✔
47	another.items.forEach(item -> items.add(cast(item)));	1✔
48	return true;	1✔
49	}
50	return false;	1✔
51	}
52
53	public String info() {
54	StringBuilder builder = new StringBuilder();	×
55	builder.append(" ").append(type().getName()).append(":");	×
56	for (StackTraceElement location : locations) {	×
57	builder.append("\n ").append(location.getClassName()).append(".").append(location.getMethodName())	×
58	.append("(").append(location.getFileName()).append(":").append(location.getLineNumber()).append(")");	×
UNCOV 59	}	×
UNCOV 60	return builder.toString();	×
61	}
62
63	public DefaultConsistency<T> absoluteProperty(PropertyChain base) {
64	DefaultConsistency<T> absolute = new DefaultConsistency<>(type(), locations);	1✔
65	items.forEach(item -> absolute.items.add(item.absoluteProperty(base)));	1✔
66	return absolute;	1✔
67	}
68
69	public Resolver resolver(ObjectProducer<?> root) {
70	return new Resolver(root);	1✔
71	}
72
73	@Override
74	public ListConsistency<T> list(String property) {
75	DefaultListConsistency<T> listConsistency = new DefaultListConsistency<>(property, this);	1✔
76	list.add(listConsistency);	1✔
77	return listConsistency;	1✔
78	}
79
80	public DefaultConsistency<T> processListConsistency(ObjectProducer<?> producer) {
81	for (DefaultListConsistency<T> listConsistency : list)	1✔
82	listConsistency.resolveToItems(producer);	1✔
83	return this;	1✔
84	}
85
86	class Resolver {
87	private final Set<ConsistencyItem<T>.Resolver> providers;
88	private final Set<ConsistencyItem<T>.Resolver> consumers;
89
90	Resolver(ObjectProducer<?> root) {	1✔
91	List<ConsistencyItem<T>.Resolver> itemResolvers = items.stream().map(i -> i.resolver(root, this)).collect(toList());	1✔
92	providers = itemResolvers.stream().filter(ConsistencyItem.Resolver::hasComposer).collect(toCollection(LinkedHashSet::new));	1✔
93	consumers = itemResolvers.stream().filter(ConsistencyItem.Resolver::hasDecomposer).collect(toCollection(LinkedHashSet::new));	1✔
94	}	1✔
95
96	Set<PropertyChain> resolve(ConsistencyItem<T>.Resolver provider) {
97	Set<PropertyChain> resolved = new HashSet<>();	1✔
98	for (ConsistencyItem<T>.Resolver consumer : consumers)	1✔
99	if (consumer != provider)	1✔
100	resolved.addAll(consumer.resolve(provider));	1✔
101	return resolved;	1✔
102	}
103
104	Optional<ConsistencyItem<T>.Resolver> searchProvider(Predicate<ConsistencyItem<?>.Resolver> condition) {
105	return providers.stream().filter(condition).min(this::onlyComposerFirstOrder);	1✔
106	}
107
108	ConsistencyItem<T>.Resolver defaultProvider() {
109	return providers.stream().min(this::onlyComposerFirstOrder).get();	1✔
110	}
111
112	private int onlyComposerFirstOrder(ConsistencyItem<T>.Resolver r1, ConsistencyItem<T>.Resolver r2) {
113	if (!r1.hasDecomposer())	1✔
114	return -1;	1✔
115	return !r2.hasDecomposer() ? 1 : 0;	1✔
116	}
117
118	Optional<ConsistencyItem<T>.Resolver> propertyRelated(PropertyChain property) {
119	return providers.stream().filter(p -> p.containsProperty(property)).findFirst();	1✔
120	}
121	}
122	}

leeonky / test-charm-java / 320

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