leeonky / test-charm-java / 335

Committed 04 Oct 2025 03:47PM UTC coverage: 74.611% (-0.04%) from 74.653%

Build # 335

Build Type

push

circleci

Committed by

leeonky

Commit Message

Process list and list consistency

Run Details

40 of 42 new or added lines in 3 files covered. (95.24%)

29 existing lines in 4 files now uncovered.

8590 of 11513 relevant lines covered (74.61%)

0.75 hits per line

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

88.73

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

package com.github.leeonky.jfactory;

import java.util.*;

import static java.util.stream.Collectors.joining;
import static java.util.stream.Collectors.toList;

class ConsistencyItem<T> {
    private final Set<PropertyChain> properties;
    private final Consistency<T> consistency;
    private final StackTraceElement location;
    private StackTraceElement composerLocation;
    private StackTraceElement decomposerLocation;
    private DefaultConsistency.Composer<T> composer;
    private DefaultConsistency.Decomposer<T> decomposer;

    ConsistencyItem(Collection<PropertyChain> properties, Consistency<T> consistency) {
        this(properties, consistency, guessCustomerPositionStackTrace());
    }

    ConsistencyItem(Collection<PropertyChain> properties, Consistency<T> consistency, StackTraceElement location) {
        this.properties = new LinkedHashSet<>(properties);
        this.consistency = consistency;
        this.location = location;
    }

    public ConsistencyItem<T> copy(DefaultConsistency<T> newConsistency) {
        ConsistencyItem<T> item = new ConsistencyItem<>(properties, newConsistency, location);
        item.decomposer = decomposer;
        item.composer = composer;
        item.decomposerLocation = decomposerLocation;
        item.composerLocation = composerLocation;
        return item;
    }

    static StackTraceElement guessCustomerPositionStackTrace() {
        StackTraceElement[] stackTrace = new Throwable().getStackTrace();
        return Arrays.stream(stackTrace).filter(s -> !s.getClassName().startsWith("com.github.leeonky.jfactory"))
                .findFirst().orElse(stackTrace[0]);
    }

    private static boolean isSame(DefaultConsistency.Identity identity1, DefaultConsistency.Identity identity2) {
        return identity1 != null && identity2 != null && identity1.same(identity2);
    }

    private static boolean isBothNull(DefaultConsistency.Identity identity1, DefaultConsistency.Identity identity2) {
        return identity1 == null && identity2 == null;
    }

    void setComposer(DefaultConsistency.Composer<T> composer) {
        this.composer = composer;
        composerLocation = composer.getLocation();
    }

    void setDecomposer(DefaultConsistency.Decomposer<T> decomposer) {
        this.decomposer = decomposer;
        decomposerLocation = decomposer.getLocation();
    }

    boolean same(ConsistencyItem<?> another) {
        return properties.equals(another.properties) &&
                (isSame(composer, another.composer) && isSame(decomposer, another.decomposer)
                        || isBothNull(composer, another.composer) && isSame(decomposer, another.decomposer)
                        || isSame(composer, another.composer) && isBothNull(decomposer, another.decomposer));
    }

    private String getPosition() {
        return location.getClassName() + "." + location.getMethodName() +
                "(" + location.getFileName() + ":" + location.getLineNumber() + ")";
    }

    private String composerLocation() {
        return composerLocation == null ? "null" :
                "(" + composerLocation.getFileName() + ":" + composerLocation.getLineNumber() + ")";
    }

    private String decomposerLocation() {
        return decomposerLocation == null ? "null" :
                "(" + decomposerLocation.getFileName() + ":" + decomposerLocation.getLineNumber() + ")";
    }

    public ConsistencyItem<T> absoluteProperty(PropertyChain base) {
        ConsistencyItem<T> absolute = new ConsistencyItem<>(properties.stream().map(base::concat).collect(toList()), consistency, location);
        absolute.decomposer = decomposer;
        absolute.composer = composer;
        absolute.decomposerLocation = decomposerLocation;
        absolute.composerLocation = composerLocation;
        return absolute;
    }

    @Override
    public String toString() {
        return properties.stream().map(Objects::toString).collect(joining(", ")) +
                " => " + consistency.type().getName() +
                (composer != null ? " with composer" : "") +
                (decomposer != null ? " with decomposer" : "");
    }

    Resolver resolver(ObjectProducer<?> root, DefaultConsistency<T>.Resolver consistency) {
        return new Resolver(root, consistency);
    }

    class Resolver {
        private final ObjectProducer<?> root;
        private final DefaultConsistency<T>.Resolver consistency;
        private Object[] cached;

        Resolver(ObjectProducer<?> root, DefaultConsistency<T>.Resolver consistency) {
            this.root = root;
            this.consistency = consistency;
        }

        boolean hasTypeOf(Class<?> type) {
            return properties.stream().map(root::descendantForRead).anyMatch(type::isInstance);
        }

        Set<PropertyChain> resolveAsProvider() {
            if (hasTypeOf(PlaceHolderProducer.class))
                return Collections.emptySet();
            return consistency.resolve(this);
        }

        private T compose() {
            return composer.apply(properties.stream().map(root::descendantForRead).map(Producer::getValue).toArray());
        }

        Object[] decompose(Resolver provider) {
            if (cached == null)
                cached = decomposer.apply(provider.compose());
            return cached;
        }

        boolean hasComposer() {
            return composer != null;
        }

        boolean hasDecomposer() {
            return decomposer != null;
        }

        Set<PropertyChain> resolve(Resolver provider) {
            int i = 0;
            for (PropertyChain property : properties) {
                int index = i++;
                root.changeDescendant(property, (producer, s) ->
                        new ConsistencyProducer<>(root.descendantForUpdate(property), provider, this, index));
            }
            return properties;
        }

        @Override
        public int hashCode() {
            return Objects.hash(properties, composer == null ? null : composer.identity(),
                    decomposer == null ? null : decomposer.identity());
        }

        private ConsistencyItem<T> outer() {
            return ConsistencyItem.this;
        }

        @Override
        @SuppressWarnings("unchecked")
        public boolean equals(Object o) {
            return o instanceof ConsistencyItem.Resolver && same(((Resolver) o).outer());
        }

        boolean hasFixed() {
            return properties.stream().map(root::descendantForRead).anyMatch(Producer::isFixed);
        }

        boolean containsProperty(PropertyChain property) {
            return properties.contains(property);
        }

        DefaultConsistency<T>.Resolver consistencyResolver() {
            return consistency;
        }
    }
}

1	package com.github.leeonky.jfactory;
2
3	import java.util.*;
4
5	import static java.util.stream.Collectors.joining;
6	import static java.util.stream.Collectors.toList;
7
8	class ConsistencyItem<T> {
9	private final Set<PropertyChain> properties;
10	private final Consistency<T> consistency;
11	private final StackTraceElement location;
12	private StackTraceElement composerLocation;
13	private StackTraceElement decomposerLocation;
14	private DefaultConsistency.Composer<T> composer;
15	private DefaultConsistency.Decomposer<T> decomposer;
16
17	ConsistencyItem(Collection<PropertyChain> properties, Consistency<T> consistency) {
18	this(properties, consistency, guessCustomerPositionStackTrace());	1✔
19	}	1✔
20
21	ConsistencyItem(Collection<PropertyChain> properties, Consistency<T> consistency, StackTraceElement location) {	1✔
22	this.properties = new LinkedHashSet<>(properties);	1✔
23	this.consistency = consistency;	1✔
24	this.location = location;	1✔
25	}	1✔
26
27	public ConsistencyItem<T> copy(DefaultConsistency<T> newConsistency) {
28	ConsistencyItem<T> item = new ConsistencyItem<>(properties, newConsistency, location);	1✔
29	item.decomposer = decomposer;	1✔
30	item.composer = composer;	1✔
31	item.decomposerLocation = decomposerLocation;	1✔
32	item.composerLocation = composerLocation;	1✔
33	return item;	1✔
34	}
35
36	static StackTraceElement guessCustomerPositionStackTrace() {
37	StackTraceElement[] stackTrace = new Throwable().getStackTrace();	1✔
38	return Arrays.stream(stackTrace).filter(s -> !s.getClassName().startsWith("com.github.leeonky.jfactory"))	1✔
39	.findFirst().orElse(stackTrace[0]);	1✔
40	}
41
42	private static boolean isSame(DefaultConsistency.Identity identity1, DefaultConsistency.Identity identity2) {
43	return identity1 != null && identity2 != null && identity1.same(identity2);	1✔
44	}
45
46	private static boolean isBothNull(DefaultConsistency.Identity identity1, DefaultConsistency.Identity identity2) {
47	return identity1 == null && identity2 == null;	1✔
48	}
49
50	void setComposer(DefaultConsistency.Composer<T> composer) {
51	this.composer = composer;	1✔
52	composerLocation = composer.getLocation();	1✔
53	}	1✔
54
55	void setDecomposer(DefaultConsistency.Decomposer<T> decomposer) {
56	this.decomposer = decomposer;	1✔
57	decomposerLocation = decomposer.getLocation();	1✔
58	}	1✔
59
60	boolean same(ConsistencyItem<?> another) {
61	return properties.equals(another.properties) &&	1✔
62	(isSame(composer, another.composer) && isSame(decomposer, another.decomposer)	1✔
63	\|\| isBothNull(composer, another.composer) && isSame(decomposer, another.decomposer)	1✔
64	\|\| isSame(composer, another.composer) && isBothNull(decomposer, another.decomposer));	1✔
65	}
66
67	private String getPosition() {
UNCOV 68	return location.getClassName() + "." + location.getMethodName() +	×
69	"(" + location.getFileName() + ":" + location.getLineNumber() + ")";	×
70	}
71
72	private String composerLocation() {
UNCOV 73	return composerLocation == null ? "null" :	×
UNCOV 74	"(" + composerLocation.getFileName() + ":" + composerLocation.getLineNumber() + ")";	×
75	}
76
77	private String decomposerLocation() {
UNCOV 78	return decomposerLocation == null ? "null" :	×
UNCOV 79	"(" + decomposerLocation.getFileName() + ":" + decomposerLocation.getLineNumber() + ")";	×
80	}
81
82	public ConsistencyItem<T> absoluteProperty(PropertyChain base) {
83	ConsistencyItem<T> absolute = new ConsistencyItem<>(properties.stream().map(base::concat).collect(toList()), consistency, location);	1✔
84	absolute.decomposer = decomposer;	1✔
85	absolute.composer = composer;	1✔
86	absolute.decomposerLocation = decomposerLocation;	1✔
87	absolute.composerLocation = composerLocation;	1✔
88	return absolute;	1✔
89	}
90
91	@Override
92	public String toString() {
UNCOV 93	return properties.stream().map(Objects::toString).collect(joining(", ")) +	×
UNCOV 94	" => " + consistency.type().getName() +	×
95	(composer != null ? " with composer" : "") +
96	(decomposer != null ? " with decomposer" : "");
97	}
98
99	Resolver resolver(ObjectProducer<?> root, DefaultConsistency<T>.Resolver consistency) {
100	return new Resolver(root, consistency);	1✔
101	}
102
103	class Resolver {
104	private final ObjectProducer<?> root;
105	private final DefaultConsistency<T>.Resolver consistency;
106	private Object[] cached;
107
108	Resolver(ObjectProducer<?> root, DefaultConsistency<T>.Resolver consistency) {	1✔
109	this.root = root;	1✔
110	this.consistency = consistency;	1✔
111	}	1✔
112
113	boolean hasTypeOf(Class<?> type) {
114	return properties.stream().map(root::descendantForRead).anyMatch(type::isInstance);	1✔
115	}
116
117	Set<PropertyChain> resolveAsProvider() {
118	if (hasTypeOf(PlaceHolderProducer.class))	1✔
119	return Collections.emptySet();	1✔
120	return consistency.resolve(this);	1✔
121	}
122
123	private T compose() {
124	return composer.apply(properties.stream().map(root::descendantForRead).map(Producer::getValue).toArray());	1✔
125	}
126
127	Object[] decompose(Resolver provider) {
128	if (cached == null)	1✔
129	cached = decomposer.apply(provider.compose());	1✔
130	return cached;	1✔
131	}
132
133	boolean hasComposer() {
134	return composer != null;	1✔
135	}
136
137	boolean hasDecomposer() {
138	return decomposer != null;	1✔
139	}
140
141	Set<PropertyChain> resolve(Resolver provider) {
142	int i = 0;	1✔
143	for (PropertyChain property : properties) {	1✔
144	int index = i++;	1✔
145	root.changeDescendant(property, (producer, s) ->	1✔
146	new ConsistencyProducer<>(root.descendantForUpdate(property), provider, this, index));	1✔
147	}	1✔
148	return properties;	1✔
149	}
150
151	@Override
152	public int hashCode() {
153	return Objects.hash(properties, composer == null ? null : composer.identity(),	1✔
154	decomposer == null ? null : decomposer.identity());	1✔
155	}
156
157	private ConsistencyItem<T> outer() {
158	return ConsistencyItem.this;	1✔
159	}
160
161	@Override
162	@SuppressWarnings("unchecked")
163	public boolean equals(Object o) {
164	return o instanceof ConsistencyItem.Resolver && same(((Resolver) o).outer());	1✔
165	}
166
167	boolean hasFixed() {
168	return properties.stream().map(root::descendantForRead).anyMatch(Producer::isFixed);	1✔
169	}
170
171	boolean containsProperty(PropertyChain property) {
172	return properties.contains(property);	1✔
173	}
174
175	DefaultConsistency<T>.Resolver consistencyResolver() {
176	return consistency;	1✔
177	}
178	}
179	}

leeonky / test-charm-java / 335

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