leeonky / test-charm-java / 314

Committed 27 Sep 2025 03:28PM UTC coverage: 71.169% (-3.2%) from 74.329%

Build # 314

Build Type

push

circleci

Committed by

leeonky

Commit Message

Update version

Run Details

7013 of 9854 relevant lines covered (71.17%)

0.71 hits per line

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

86.89

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

package com.github.leeonky.jfactory;

import java.util.*;

import static com.github.leeonky.jfactory.AbstractConsistency.Identity.isBothNull;
import static com.github.leeonky.jfactory.AbstractConsistency.Identity.isSame;
import static java.util.stream.Collectors.joining;
import static java.util.stream.Collectors.toList;

class ConsistencyItem<T> {
    private final Set<PropertyChain> properties;
    private final DefaultConsistency<T> consistency;
    private final StackTraceElement location;
    private StackTraceElement composerLocation;
    private StackTraceElement decomposerLocation;
    private AbstractConsistency.Composer<T> composer;
    private AbstractConsistency.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 = (DefaultConsistency<T>) 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]);
    }

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

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

    public 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" : "");
    }

    public 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::descendant).anyMatch(type::isInstance);
        }

        Set<PropertyChain> resolveAsProvider() {
            return consistency.resolve(this);
        }

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

leeonky / test-charm-java / 314

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