leeonky / test-charm-java / 311

Committed 27 Sep 2025 10:36AM UTC coverage: 74.329% (+3.1%) from 71.191%

Build # 311

Build Type

push

circleci

Committed by

leeonky

Commit Message

Remove useless code

Run Details

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

43 existing lines in 9 files now uncovered.

8397 of 11297 relevant lines covered (74.33%)

0.74 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 com.github.leeonky.jfactory.Consistency.Identity.isBothNull;
import static com.github.leeonky.jfactory.Consistency.Identity.isSame;
import static java.util.stream.Collectors.joining;
import static java.util.stream.Collectors.toList;

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

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

    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;
        final DefaultConsistency<T>.Resolver consistency;
        Object[] cached;

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

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

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

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

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

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

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

        public 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
        public boolean equals(Object o) {
            return o instanceof ConsistencyItem.Resolver &&
                    same(((Resolver) o).outer());
        }

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

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

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

leeonky / test-charm-java / 311

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