leeonky / test-charm-java / 323

Committed 30 Sep 2025 05:15PM UTC coverage: 74.637% (+0.1%) from 74.512%

Build # 323

Build Type

push

circleci

Committed by

leeonky

Commit Message

Use descendantForRead in consistent provider

Run Details

16 of 17 new or added lines in 4 files covered. (94.12%)

29 existing lines in 7 files now uncovered.

8531 of 11430 relevant lines covered (74.64%)

0.75 hits per line

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

87.69

/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;
    }

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

leeonky / test-charm-java / 323

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