leeonky / test-charm-java / 332

Committed 02 Oct 2025 03:38PM UTC coverage: 74.653% (-0.03%) from 74.68%

Build # 332

Build Type

push

circleci

Committed by

leeonky

Commit Message

Refactor

Run Details

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

16 existing lines in 5 files now uncovered.

8559 of 11465 relevant lines covered (74.65%)

0.75 hits per line

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

94.12

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

package com.github.leeonky.jfactory;

import com.github.leeonky.util.BeanClass;

import java.math.BigDecimal;
import java.math.BigInteger;
import java.time.*;
import java.time.temporal.ChronoUnit;
import java.util.*;

import static java.util.Optional.ofNullable;

public class DefaultValueFactories {
    private static final LocalDate LOCAL_DATE_START = LocalDate.parse("1996-01-23");
    private static final LocalDateTime LOCAL_DATE_TIME_START = LocalDateTime.parse("1996-01-23T00:00:00");
    private static final LocalTime LOCAL_TIME_START = LocalTime.parse("00:00:00");
    private static final Instant INSTANT_START = Instant.parse("1996-01-23T00:00:00Z");
    private final Map<Class<?>, DefaultValueFactory<?>> defaultValueBuilders = new HashMap<>();

    DefaultValueFactories() {
        register(String.class, new DefaultStringFactory());
        register(Integer.class, new DefaultIntegerFactory());
        register(int.class, defaultValueBuilders.get(Integer.class));
        register(Short.class, new DefaultShortFactory());
        register(short.class, defaultValueBuilders.get(Short.class));
        register(Byte.class, new DefaultByteFactory());
        register(byte.class, defaultValueBuilders.get(Byte.class));
        register(Long.class, new DefaultLongFactory());
        register(long.class, defaultValueBuilders.get(Long.class));
        register(Float.class, new DefaultFloatFactory());
        register(float.class, defaultValueBuilders.get(Float.class));
        register(Double.class, new DefaultDoubleFactory());
        register(double.class, defaultValueBuilders.get(Double.class));
        register(Boolean.class, new DefaultBooleanFactory());
        register(boolean.class, defaultValueBuilders.get(Boolean.class));
        register(BigInteger.class, new DefaultBigIntegerFactory());
        register(BigDecimal.class, new DefaultBigDecimalFactory());
        register(UUID.class, new DefaultUUIDFactory());
        register(Date.class, new DefaultDateFactory());
        register(Instant.class, new DefaultInstantFactory());
        register(LocalDate.class, new DefaultLocalDateFactory());
        register(LocalTime.class, new DefaultLocalTimeFactory());
        register(LocalDateTime.class, new DefaultLocalDateTimeFactory());
        register(OffsetDateTime.class, new DefaultOffsetDateTimeFactory());
        register(ZonedDateTime.class, new DefaultZoneDateTimeFactory());
        register(Enum.class, new DefaultEnumFactory());
    }

    public void register(Class<?> type, DefaultValueFactory<?> factory) {
        defaultValueBuilders.put(type, factory);
    }

    @SuppressWarnings("unchecked")
    public <T> Optional<DefaultValueFactory<T>> query(Class<T> type) {
        DefaultValueFactory<?> defaultValueFactory = defaultValueBuilders.get(type);
        if (type.isEnum())
            defaultValueFactory = defaultValueBuilders.get(Enum.class);
        return ofNullable((DefaultValueFactory<T>) defaultValueFactory);
    }

    public static class DefaultStringFactory implements DefaultValueFactory<String> {

        @Override
        public <T> String create(BeanClass<T> beanType, SubInstance<T> instance) {
            return instance.propertyInfo();
        }
    }

    public static class DefaultLongFactory implements DefaultValueFactory<Long> {

        @Override
        public <T> Long create(BeanClass<T> beanType, SubInstance<T> instance) {
            return (long) instance.getSequence();
        }
    }

    public static class DefaultIntegerFactory implements DefaultValueFactory<Integer> {

        @Override
        public <T> Integer create(BeanClass<T> beanType, SubInstance<T> instance) {
            return instance.getSequence();
        }
    }

    public static class DefaultShortFactory implements DefaultValueFactory<Short> {

        @Override
        public <T> Short create(BeanClass<T> beanType, SubInstance<T> instance) {
            return (short) instance.getSequence();
        }
    }

    public static class DefaultByteFactory implements DefaultValueFactory<Byte> {

        @Override
        public <T> Byte create(BeanClass<T> beanType, SubInstance<T> instance) {
            return (byte) instance.getSequence();
        }
    }

    public static class DefaultDoubleFactory implements DefaultValueFactory<Double> {

        @Override
        public <T> Double create(BeanClass<T> beanType, SubInstance<T> instance) {
            return (double) instance.getSequence();
        }
    }

    public static class DefaultFloatFactory implements DefaultValueFactory<Float> {

        @Override
        public <T> Float create(BeanClass<T> beanType, SubInstance<T> instance) {
            return (float) instance.getSequence();
        }
    }

    public static class DefaultBooleanFactory implements DefaultValueFactory<Boolean> {

        @Override
        public <T> Boolean create(BeanClass<T> beanType, SubInstance<T> instance) {
            return (instance.getSequence() % 2) == 1;
        }
    }

    public static class DefaultBigIntegerFactory implements DefaultValueFactory<BigInteger> {

        @Override
        public <T> BigInteger create(BeanClass<T> beanType, SubInstance<T> instance) {
            return BigInteger.valueOf(instance.getSequence());
        }
    }

    public static class DefaultBigDecimalFactory implements DefaultValueFactory<BigDecimal> {

        @Override
        public <T> BigDecimal create(BeanClass<T> beanType, SubInstance<T> instance) {
            return BigDecimal.valueOf(instance.getSequence());
        }
    }

    public static class DefaultUUIDFactory implements DefaultValueFactory<UUID> {

        @Override
        public <T> UUID create(BeanClass<T> beanType, SubInstance<T> instance) {
            return UUID.fromString(String.format("00000000-0000-0000-0000-%012d", instance.getSequence()));
        }
    }

    public static class DefaultDateFactory implements DefaultValueFactory<Date> {

        @Override
        public <T> Date create(BeanClass<T> beanType, SubInstance<T> instance) {
            return Date.from(INSTANT_START.plus(instance.getSequence(), ChronoUnit.DAYS));
        }
    }

    public static class DefaultInstantFactory implements DefaultValueFactory<Instant> {

        @Override
        public <T> Instant create(BeanClass<T> beanType, SubInstance<T> instance) {
            return INSTANT_START.plusSeconds(instance.getSequence());
        }
    }

    public static class DefaultLocalTimeFactory implements DefaultValueFactory<LocalTime> {

        @Override
        public <T> LocalTime create(BeanClass<T> beanType, SubInstance<T> instance) {
            return LOCAL_TIME_START.plusSeconds(instance.getSequence());
        }
    }

    public static class DefaultLocalDateFactory implements DefaultValueFactory<LocalDate> {

        @Override
        public <T> LocalDate create(BeanClass<T> beanType, SubInstance<T> instance) {
            return LOCAL_DATE_START.plusDays(instance.getSequence());
        }
    }

    public static class DefaultLocalDateTimeFactory implements DefaultValueFactory<LocalDateTime> {

        @Override
        public <T> LocalDateTime create(BeanClass<T> beanType, SubInstance<T> instance) {
            return LOCAL_DATE_TIME_START.plusSeconds(instance.getSequence());
        }
    }

    public static class DefaultOffsetDateTimeFactory implements DefaultValueFactory<OffsetDateTime> {

        @Override
        public <T> OffsetDateTime create(BeanClass<T> beanType, SubInstance<T> instance) {
            return INSTANT_START.plusSeconds(instance.getSequence()).atZone(ZoneId.systemDefault()).toOffsetDateTime();
        }
    }

    public static class DefaultZoneDateTimeFactory implements DefaultValueFactory<ZonedDateTime> {

        @Override
        public <T> ZonedDateTime create(BeanClass<T> beanType, SubInstance<T> instance) {
            return INSTANT_START.plusSeconds(instance.getSequence()).atZone(ZoneId.systemDefault());
        }
    }

    public static class DefaultEnumFactory implements DefaultValueFactory<Object> {

        @Override
        public <T> Object create(BeanClass<T> beanType, SubInstance<T> instance) {
            BeanClass<?> propertyType = instance.getProperty().getType();
            Object[] enumConstants = (propertyType.isCollection() ? propertyType.getElementType() : propertyType)
                    .getType().getEnumConstants();
            return enumConstants[(instance.getSequence() - 1) % enumConstants.length];
        }
    }

    public static class DefaultTypeFactory<V> implements DefaultValueFactory<V> {
        private final BeanClass<V> type;

        public DefaultTypeFactory(BeanClass<V> type) {
            this.type = type;
        }

        @Override
        public <T> V create(BeanClass<T> beanType, SubInstance<T> instance) {
            return type.createDefault();
        }

        @Override
        public Class<V> getType() {
            return type.getType();
        }
    }
}

1	package com.github.leeonky.jfactory;
2
3	import com.github.leeonky.util.BeanClass;
4
5	import java.math.BigDecimal;
6	import java.math.BigInteger;
7	import java.time.*;
8	import java.time.temporal.ChronoUnit;
9	import java.util.*;
10
11	import static java.util.Optional.ofNullable;
12
13	public class DefaultValueFactories {
14	private static final LocalDate LOCAL_DATE_START = LocalDate.parse("1996-01-23");	1✔
15	private static final LocalDateTime LOCAL_DATE_TIME_START = LocalDateTime.parse("1996-01-23T00:00:00");	1✔
16	private static final LocalTime LOCAL_TIME_START = LocalTime.parse("00:00:00");	1✔
17	private static final Instant INSTANT_START = Instant.parse("1996-01-23T00:00:00Z");	1✔
18	private final Map<Class<?>, DefaultValueFactory<?>> defaultValueBuilders = new HashMap<>();	1✔
19
20	DefaultValueFactories() {	1✔
21	register(String.class, new DefaultStringFactory());	1✔
22	register(Integer.class, new DefaultIntegerFactory());	1✔
23	register(int.class, defaultValueBuilders.get(Integer.class));	1✔
24	register(Short.class, new DefaultShortFactory());	1✔
25	register(short.class, defaultValueBuilders.get(Short.class));	1✔
26	register(Byte.class, new DefaultByteFactory());	1✔
27	register(byte.class, defaultValueBuilders.get(Byte.class));	1✔
28	register(Long.class, new DefaultLongFactory());	1✔
29	register(long.class, defaultValueBuilders.get(Long.class));	1✔
30	register(Float.class, new DefaultFloatFactory());	1✔
31	register(float.class, defaultValueBuilders.get(Float.class));	1✔
32	register(Double.class, new DefaultDoubleFactory());	1✔
33	register(double.class, defaultValueBuilders.get(Double.class));	1✔
34	register(Boolean.class, new DefaultBooleanFactory());	1✔
35	register(boolean.class, defaultValueBuilders.get(Boolean.class));	1✔
36	register(BigInteger.class, new DefaultBigIntegerFactory());	1✔
37	register(BigDecimal.class, new DefaultBigDecimalFactory());	1✔
38	register(UUID.class, new DefaultUUIDFactory());	1✔
39	register(Date.class, new DefaultDateFactory());	1✔
40	register(Instant.class, new DefaultInstantFactory());	1✔
41	register(LocalDate.class, new DefaultLocalDateFactory());	1✔
42	register(LocalTime.class, new DefaultLocalTimeFactory());	1✔
43	register(LocalDateTime.class, new DefaultLocalDateTimeFactory());	1✔
44	register(OffsetDateTime.class, new DefaultOffsetDateTimeFactory());	1✔
45	register(ZonedDateTime.class, new DefaultZoneDateTimeFactory());	1✔
46	register(Enum.class, new DefaultEnumFactory());	1✔
47	}	1✔
48
49	public void register(Class<?> type, DefaultValueFactory<?> factory) {
50	defaultValueBuilders.put(type, factory);	1✔
51	}	1✔
52
53	@SuppressWarnings("unchecked")
54	public <T> Optional<DefaultValueFactory<T>> query(Class<T> type) {
55	DefaultValueFactory<?> defaultValueFactory = defaultValueBuilders.get(type);	1✔
56	if (type.isEnum())	1✔
57	defaultValueFactory = defaultValueBuilders.get(Enum.class);	1✔
58	return ofNullable((DefaultValueFactory<T>) defaultValueFactory);	1✔
59	}
60
61	public static class DefaultStringFactory implements DefaultValueFactory<String> {	1✔
62
63	@Override
64	public <T> String create(BeanClass<T> beanType, SubInstance<T> instance) {
65	return instance.propertyInfo();	1✔
66	}
67	}
68
69	public static class DefaultLongFactory implements DefaultValueFactory<Long> {	1✔
70
71	@Override
72	public <T> Long create(BeanClass<T> beanType, SubInstance<T> instance) {
73	return (long) instance.getSequence();	1✔
74	}
75	}
76
77	public static class DefaultIntegerFactory implements DefaultValueFactory<Integer> {	1✔
78
79	@Override
80	public <T> Integer create(BeanClass<T> beanType, SubInstance<T> instance) {
81	return instance.getSequence();	1✔
82	}
83	}
84
85	public static class DefaultShortFactory implements DefaultValueFactory<Short> {	1✔
86
87	@Override
88	public <T> Short create(BeanClass<T> beanType, SubInstance<T> instance) {
89	return (short) instance.getSequence();	1✔
90	}
91	}
92
93	public static class DefaultByteFactory implements DefaultValueFactory<Byte> {	1✔
94
95	@Override
96	public <T> Byte create(BeanClass<T> beanType, SubInstance<T> instance) {
97	return (byte) instance.getSequence();	1✔
98	}
99	}
100
101	public static class DefaultDoubleFactory implements DefaultValueFactory<Double> {	1✔
102
103	@Override
104	public <T> Double create(BeanClass<T> beanType, SubInstance<T> instance) {
105	return (double) instance.getSequence();	1✔
106	}
107	}
108
109	public static class DefaultFloatFactory implements DefaultValueFactory<Float> {	1✔
110
111	@Override
112	public <T> Float create(BeanClass<T> beanType, SubInstance<T> instance) {
113	return (float) instance.getSequence();	1✔
114	}
115	}
116
117	public static class DefaultBooleanFactory implements DefaultValueFactory<Boolean> {	1✔
118
119	@Override
120	public <T> Boolean create(BeanClass<T> beanType, SubInstance<T> instance) {
121	return (instance.getSequence() % 2) == 1;	1✔
122	}
123	}
124
125	public static class DefaultBigIntegerFactory implements DefaultValueFactory<BigInteger> {	1✔
126
127	@Override
128	public <T> BigInteger create(BeanClass<T> beanType, SubInstance<T> instance) {
129	return BigInteger.valueOf(instance.getSequence());	1✔
130	}
131	}
132
133	public static class DefaultBigDecimalFactory implements DefaultValueFactory<BigDecimal> {	1✔
134
135	@Override
136	public <T> BigDecimal create(BeanClass<T> beanType, SubInstance<T> instance) {
137	return BigDecimal.valueOf(instance.getSequence());	1✔
138	}
139	}
140
141	public static class DefaultUUIDFactory implements DefaultValueFactory<UUID> {	1✔
142
143	@Override
144	public <T> UUID create(BeanClass<T> beanType, SubInstance<T> instance) {
145	return UUID.fromString(String.format("00000000-0000-0000-0000-%012d", instance.getSequence()));	1✔
146	}
147	}
148
149	public static class DefaultDateFactory implements DefaultValueFactory<Date> {	1✔
150
151	@Override
152	public <T> Date create(BeanClass<T> beanType, SubInstance<T> instance) {
153	return Date.from(INSTANT_START.plus(instance.getSequence(), ChronoUnit.DAYS));	1✔
154	}
155	}
156
157	public static class DefaultInstantFactory implements DefaultValueFactory<Instant> {	1✔
158
159	@Override
160	public <T> Instant create(BeanClass<T> beanType, SubInstance<T> instance) {
161	return INSTANT_START.plusSeconds(instance.getSequence());	1✔
162	}
163	}
164
165	public static class DefaultLocalTimeFactory implements DefaultValueFactory<LocalTime> {	1✔
166
167	@Override
168	public <T> LocalTime create(BeanClass<T> beanType, SubInstance<T> instance) {
169	return LOCAL_TIME_START.plusSeconds(instance.getSequence());	1✔
170	}
171	}
172
173	public static class DefaultLocalDateFactory implements DefaultValueFactory<LocalDate> {	1✔
174
175	@Override
176	public <T> LocalDate create(BeanClass<T> beanType, SubInstance<T> instance) {
177	return LOCAL_DATE_START.plusDays(instance.getSequence());	1✔
178	}
179	}
180
181	public static class DefaultLocalDateTimeFactory implements DefaultValueFactory<LocalDateTime> {	1✔
182
183	@Override
184	public <T> LocalDateTime create(BeanClass<T> beanType, SubInstance<T> instance) {
185	return LOCAL_DATE_TIME_START.plusSeconds(instance.getSequence());	1✔
186	}
187	}
188
189	public static class DefaultOffsetDateTimeFactory implements DefaultValueFactory<OffsetDateTime> {	1✔
190
191	@Override
192	public <T> OffsetDateTime create(BeanClass<T> beanType, SubInstance<T> instance) {
193	return INSTANT_START.plusSeconds(instance.getSequence()).atZone(ZoneId.systemDefault()).toOffsetDateTime();	1✔
194	}
195	}
196
197	public static class DefaultZoneDateTimeFactory implements DefaultValueFactory<ZonedDateTime> {	1✔
198
199	@Override
200	public <T> ZonedDateTime create(BeanClass<T> beanType, SubInstance<T> instance) {
201	return INSTANT_START.plusSeconds(instance.getSequence()).atZone(ZoneId.systemDefault());	1✔
202	}
203	}
204
205	public static class DefaultEnumFactory implements DefaultValueFactory<Object> {	1✔
206
207	@Override
208	public <T> Object create(BeanClass<T> beanType, SubInstance<T> instance) {
209	BeanClass<?> propertyType = instance.getProperty().getType();	1✔
210	Object[] enumConstants = (propertyType.isCollection() ? propertyType.getElementType() : propertyType)	1✔
211	.getType().getEnumConstants();	1✔
212	return enumConstants[(instance.getSequence() - 1) % enumConstants.length];	1✔
213	}
214	}
215
216	public static class DefaultTypeFactory<V> implements DefaultValueFactory<V> {
217	private final BeanClass<V> type;
218
UNCOV 219	public DefaultTypeFactory(BeanClass<V> type) {	×
UNCOV 220	this.type = type;	×
UNCOV 221	}	×
222
223	@Override
224	public <T> V create(BeanClass<T> beanType, SubInstance<T> instance) {
UNCOV 225	return type.createDefault();	×
226	}
227
228	@Override
229	public Class<V> getType() {
UNCOV 230	return type.getType();	×
231	}
232	}
233	}

leeonky / test-charm-java / 332

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