leeonky / test-charm-java / 206

Committed 09 Apr 2025 01:43AM UTC coverage: 74.136% (+4.0%) from 70.149%

Build # 206

Build Type

push

circleci

Committed by

leeonky

Commit Message

Update log version

Run Details

8003 of 10795 relevant lines covered (74.14%)

0.74 hits per line

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

94.87

/DAL-java/src/main/java/com/github/leeonky/dal/format/Formatters.java

package com.github.leeonky.dal.format;

import com.github.leeonky.dal.runtime.IllegalTypeException;
import com.github.leeonky.util.Sneaky;
import com.github.leeonky.util.function.Comparator;

import java.math.BigDecimal;
import java.math.BigInteger;
import java.time.format.DateTimeParseException;

import static java.lang.Enum.valueOf;
import static java.lang.String.format;

public class Formatters {
    /**
     * Use com.github.leeonky.dal.format.Type
     */
    @Deprecated
    public static class String extends BaseFormatter<java.lang.String, java.lang.String> {
        @Override
        public java.lang.String convert(java.lang.String input) {
            return input;
        }
    }

    public static class Instant extends BaseFormatter<java.lang.String, java.time.Instant> {

        public static Instant now(int errorMs) {
            return new Instant() {
                private java.time.Instant now;

                @Override
                public boolean isValidValue(java.time.Instant actual) {
                    now = java.time.Instant.now();
                    return actual.isAfter(now.plusMillis(-errorMs)) && actual.isBefore(now.plusMillis(errorMs));
                }

                @Override
                public java.lang.String getFormatterName() {
                    return format("Instant now[%s] +/- %dms", now, errorMs);
                }
            };
        }

        public static Instant now() {
            return now(10000);
        }

        @Override
        public java.time.Instant convert(java.lang.String input) {
            return Sneaky.get(() -> java.time.Instant.parse(input));
        }
    }

    public static class PositiveInteger extends Integer {
        @Override
        public BigInteger convert(java.lang.Number input) {
            BigInteger value = super.convert(input);
            if (value.compareTo(BigInteger.ZERO) <= 0)
                throw new IllegalTypeException();
            return value;
        }
    }

    //TODO  keep origin type, 1.0 => should integer
    public static class Integer extends BaseFormatter<java.lang.Number, BigInteger> {
        public static Integer equalTo(long expect) {
            return compare(expect, Comparator.equalTo(0), "equal to");
        }

        public static Integer positive() {
            return greaterThan(0);
        }

        public static Integer greaterThan(long expect) {
            return compare(expect, Comparator.greaterThan(0), "greater than");
        }

        public static Integer lessThan(long expect) {
            return compare(expect, Comparator.lessThan(0), "less than");
        }

        public static Integer negative() {
            return lessThan(0);
        }

        public static Integer greaterOrEqualTo(long expect) {
            return compare(expect, Comparator.greaterOrEqualTo(0), "greater or equal to");
        }

        public static Integer lessOrEqualTo(long expect) {
            return compare(expect, Comparator.lessOrEqualTo(0), "less or equal to");
        }

        public static Integer compare(long expect, Comparator<java.lang.Integer> comparator,
                                      java.lang.String formatterName) {
            return new Integer() {
                @Override
                public boolean isValidValue(BigInteger value) {
                    return comparator.compareTo(value.compareTo(BigInteger.valueOf(expect)));
                }

                @Override
                public java.lang.String getFormatterName() {
                    return format("Integer %s [%d]", formatterName, expect);
                }
            };
        }

        @Override
        public BigInteger convert(java.lang.Number input) {
            if (input instanceof Double
                    || input instanceof Float
                    || (input instanceof BigDecimal && ((BigDecimal) input).scale() != 0)) {
                throw new IllegalTypeException();
            }
            return new BigInteger(input.toString());
        }
    }

    public static class URL extends BaseFormatter<java.lang.String, java.net.URL> {

        @Override
        public java.net.URL convert(java.lang.String input) {
            return Sneaky.get(() -> new java.net.URL(input));
        }
    }

    public static class URI extends BaseFormatter<java.lang.String, java.net.URI> {

        @Override
        public java.net.URI convert(java.lang.String input) {
            return Sneaky.get(() -> new java.net.URI(input));
        }
    }

    public static class Enum<T extends java.lang.Enum<T>> extends BaseFormatter<java.lang.String, T> {
        private final Class<T> enumType;

        public Enum() {
            this(null);
        }

        public Enum(Class<T> enumType) {
            this.enumType = enumType;
        }

        @Override
        public T convert(java.lang.String input) {
            return enumType == null ? defaultVerification(input) : verifyViaEnumType(input);
        }

        private T verifyViaEnumType(java.lang.String input) {
            try {
                return valueOf(enumType, input);
            } catch (Exception e) {
                throw new IllegalTypeException();
            }
        }

        private T defaultVerification(java.lang.String input) {
            if (input.chars().filter(Character::isLetter)
                    .anyMatch(Character::isLowerCase))
                throw new IllegalTypeException();
            return null;
        }
    }

    public static class Number extends BaseFormatter<java.lang.Number, java.math.BigDecimal> {

        public static Number equalTo(java.lang.Number expect) {
            return compare(expect, Comparator.equalTo(0), "equal to");
        }

        public static Number compare(java.lang.Number expect, Comparator<java.lang.Integer> comparator,
                                     java.lang.String formatterName) {
            return new Number() {
                @Override
                public boolean isValidValue(BigDecimal value) {
                    return comparator.compareTo(value.compareTo(new BigDecimal(expect.toString())));
                }

                @Override
                public java.lang.String getFormatterName() {
                    return format("Number %s [%s]", formatterName, expect);
                }
            };
        }

        public static Number positive() {
            return greaterThan(0);
        }

        public static Number greaterThan(java.lang.Number expect) {
            return compare(expect, Comparator.greaterThan(0), "greater than");
        }

        public static Number negative() {
            return lessThan(0);
        }

        public static Number lessThan(java.lang.Number expect) {
            return compare(expect, Comparator.lessThan(0), "less than");
        }

        public static Number greaterOrEqualTo(java.lang.Number expect) {
            return compare(expect, Comparator.greaterOrEqualTo(0), "greater or equal to");
        }

        public static Number lessOrEqualTo(java.lang.Number expect) {
            return compare(expect, Comparator.lessOrEqualTo(0), "less or equal to");
        }

        @Override
        public java.math.BigDecimal convert(java.lang.Number input) {
            return new BigDecimal(input.toString());
        }
    }

    public static class PositiveNumber extends BaseFormatter<java.lang.Number, BigDecimal> {

        @Override
        public BigDecimal convert(java.lang.Number input) {
            BigDecimal decimal = new BigDecimal(input.toString());
            if (decimal.compareTo(BigDecimal.ZERO) <= 0)
                throw new IllegalTypeException();
            return decimal;
        }
    }

    public static class ZeroNumber extends BaseFormatter<java.lang.Number, java.lang.Integer> {

        @Override
        public java.lang.Integer convert(java.lang.Number input) {
            if (new BigDecimal(input.toString()).compareTo(BigDecimal.ZERO) != 0)
                throw new IllegalTypeException();
            return 0;
        }
    }

    public static class LocalDate extends BaseFormatter<java.lang.String, java.time.LocalDate> {

        @Override
        public java.time.LocalDate convert(java.lang.String input) {
            try {
                return java.time.LocalDate.parse(input);
            } catch (DateTimeParseException ignore) {
                throw new IllegalTypeException();
            }
        }
    }

    public static class LocalDateTime extends BaseFormatter<java.lang.String, java.time.LocalDateTime> {

        @Override
        public java.time.LocalDateTime convert(java.lang.String input) {
            try {
                return java.time.LocalDateTime.parse(input);
            } catch (DateTimeParseException ignore) {
                throw new IllegalTypeException();
            }
        }
    }

    public static class Boolean extends BaseFormatter<java.lang.Boolean, java.lang.Boolean> {
        @Override
        public java.lang.Boolean convert(java.lang.Boolean input) {
            return input;
        }
    }
}

1	package com.github.leeonky.dal.format;
2
3	import com.github.leeonky.dal.runtime.IllegalTypeException;
4	import com.github.leeonky.util.Sneaky;
5	import com.github.leeonky.util.function.Comparator;
6
7	import java.math.BigDecimal;
8	import java.math.BigInteger;
9	import java.time.format.DateTimeParseException;
10
11	import static java.lang.Enum.valueOf;
12	import static java.lang.String.format;
13
14	public class Formatters {	×
15	/**
16	* Use com.github.leeonky.dal.format.Type
17	*/
18	@Deprecated
19	public static class String extends BaseFormatter<java.lang.String, java.lang.String> {	1✔
20	@Override
21	public java.lang.String convert(java.lang.String input) {
22	return input;	1✔
23	}
24	}
25
26	public static class Instant extends BaseFormatter<java.lang.String, java.time.Instant> {	1✔
27
28	public static Instant now(int errorMs) {
29	return new Instant() {	1✔
30	private java.time.Instant now;
31
32	@Override
33	public boolean isValidValue(java.time.Instant actual) {
34	now = java.time.Instant.now();	1✔
35	return actual.isAfter(now.plusMillis(-errorMs)) && actual.isBefore(now.plusMillis(errorMs));	1✔
36	}
37
38	@Override
39	public java.lang.String getFormatterName() {
40	return format("Instant now[%s] +/- %dms", now, errorMs);	1✔
41	}
42	};
43	}
44
45	public static Instant now() {
46	return now(10000);	1✔
47	}
48
49	@Override
50	public java.time.Instant convert(java.lang.String input) {
51	return Sneaky.get(() -> java.time.Instant.parse(input));	1✔
52	}
53	}
54
55	public static class PositiveInteger extends Integer {	1✔
56	@Override
57	public BigInteger convert(java.lang.Number input) {
58	BigInteger value = super.convert(input);	1✔
59	if (value.compareTo(BigInteger.ZERO) <= 0)	1✔
60	throw new IllegalTypeException();	1✔
61	return value;	1✔
62	}
63	}
64
65	//TODO keep origin type, 1.0 => should integer
66	public static class Integer extends BaseFormatter<java.lang.Number, BigInteger> {	1✔
67	public static Integer equalTo(long expect) {
68	return compare(expect, Comparator.equalTo(0), "equal to");	1✔
69	}
70
71	public static Integer positive() {
72	return greaterThan(0);	1✔
73	}
74
75	public static Integer greaterThan(long expect) {
76	return compare(expect, Comparator.greaterThan(0), "greater than");	1✔
77	}
78
79	public static Integer lessThan(long expect) {
80	return compare(expect, Comparator.lessThan(0), "less than");	1✔
81	}
82
83	public static Integer negative() {
84	return lessThan(0);	1✔
85	}
86
87	public static Integer greaterOrEqualTo(long expect) {
88	return compare(expect, Comparator.greaterOrEqualTo(0), "greater or equal to");	1✔
89	}
90
91	public static Integer lessOrEqualTo(long expect) {
92	return compare(expect, Comparator.lessOrEqualTo(0), "less or equal to");	1✔
93	}
94
95	public static Integer compare(long expect, Comparator<java.lang.Integer> comparator,
96	java.lang.String formatterName) {
97	return new Integer() {	1✔
98	@Override
99	public boolean isValidValue(BigInteger value) {
100	return comparator.compareTo(value.compareTo(BigInteger.valueOf(expect)));	1✔
101	}
102
103	@Override
104	public java.lang.String getFormatterName() {
105	return format("Integer %s [%d]", formatterName, expect);	1✔
106	}
107	};
108	}
109
110	@Override
111	public BigInteger convert(java.lang.Number input) {
112	if (input instanceof Double	1✔
113	\|\| input instanceof Float
114	\|\| (input instanceof BigDecimal && ((BigDecimal) input).scale() != 0)) {	×
115	throw new IllegalTypeException();	1✔
116	}
117	return new BigInteger(input.toString());	1✔
118	}
119	}
120
121	public static class URL extends BaseFormatter<java.lang.String, java.net.URL> {	1✔
122
123	@Override
124	public java.net.URL convert(java.lang.String input) {
125	return Sneaky.get(() -> new java.net.URL(input));	1✔
126	}
127	}
128
129	public static class URI extends BaseFormatter<java.lang.String, java.net.URI> {	1✔
130
131	@Override
132	public java.net.URI convert(java.lang.String input) {
133	return Sneaky.get(() -> new java.net.URI(input));	×
134	}
135	}
136
137	public static class Enum<T extends java.lang.Enum<T>> extends BaseFormatter<java.lang.String, T> {
138	private final Class<T> enumType;
139
140	public Enum() {
141	this(null);	1✔
142	}	1✔
143
144	public Enum(Class<T> enumType) {	1✔
145	this.enumType = enumType;	1✔
146	}	1✔
147
148	@Override
149	public T convert(java.lang.String input) {
150	return enumType == null ? defaultVerification(input) : verifyViaEnumType(input);	1✔
151	}
152
153	private T verifyViaEnumType(java.lang.String input) {
154	try {
155	return valueOf(enumType, input);	1✔
156	} catch (Exception e) {	1✔
157	throw new IllegalTypeException();	1✔
158	}
159	}
160
161	private T defaultVerification(java.lang.String input) {
162	if (input.chars().filter(Character::isLetter)	1✔
163	.anyMatch(Character::isLowerCase))	1✔
164	throw new IllegalTypeException();	1✔
165	return null;	1✔
166	}
167	}
168
169	public static class Number extends BaseFormatter<java.lang.Number, java.math.BigDecimal> {	1✔
170
171	public static Number equalTo(java.lang.Number expect) {
172	return compare(expect, Comparator.equalTo(0), "equal to");	1✔
173	}
174
175	public static Number compare(java.lang.Number expect, Comparator<java.lang.Integer> comparator,
176	java.lang.String formatterName) {
177	return new Number() {	1✔
178	@Override
179	public boolean isValidValue(BigDecimal value) {
180	return comparator.compareTo(value.compareTo(new BigDecimal(expect.toString())));	1✔
181	}
182
183	@Override
184	public java.lang.String getFormatterName() {
185	return format("Number %s [%s]", formatterName, expect);	1✔
186	}
187	};
188	}
189
190	public static Number positive() {
191	return greaterThan(0);	1✔
192	}
193
194	public static Number greaterThan(java.lang.Number expect) {
195	return compare(expect, Comparator.greaterThan(0), "greater than");	1✔
196	}
197
198	public static Number negative() {
199	return lessThan(0);	1✔
200	}
201
202	public static Number lessThan(java.lang.Number expect) {
203	return compare(expect, Comparator.lessThan(0), "less than");	1✔
204	}
205
206	public static Number greaterOrEqualTo(java.lang.Number expect) {
207	return compare(expect, Comparator.greaterOrEqualTo(0), "greater or equal to");	1✔
208	}
209
210	public static Number lessOrEqualTo(java.lang.Number expect) {
211	return compare(expect, Comparator.lessOrEqualTo(0), "less or equal to");	1✔
212	}
213
214	@Override
215	public java.math.BigDecimal convert(java.lang.Number input) {
216	return new BigDecimal(input.toString());	1✔
217	}
218	}
219
220	public static class PositiveNumber extends BaseFormatter<java.lang.Number, BigDecimal> {	1✔
221
222	@Override
223	public BigDecimal convert(java.lang.Number input) {
224	BigDecimal decimal = new BigDecimal(input.toString());	1✔
225	if (decimal.compareTo(BigDecimal.ZERO) <= 0)	1✔
226	throw new IllegalTypeException();	1✔
227	return decimal;	1✔
228	}
229	}
230
231	public static class ZeroNumber extends BaseFormatter<java.lang.Number, java.lang.Integer> {	1✔
232
233	@Override
234	public java.lang.Integer convert(java.lang.Number input) {
235	if (new BigDecimal(input.toString()).compareTo(BigDecimal.ZERO) != 0)	1✔
236	throw new IllegalTypeException();	×
237	return 0;	1✔
238	}
239	}
240
241	public static class LocalDate extends BaseFormatter<java.lang.String, java.time.LocalDate> {	1✔
242
243	@Override
244	public java.time.LocalDate convert(java.lang.String input) {
245	try {
246	return java.time.LocalDate.parse(input);	1✔
247	} catch (DateTimeParseException ignore) {	1✔
248	throw new IllegalTypeException();	1✔
249	}
250	}
251	}
252
253	public static class LocalDateTime extends BaseFormatter<java.lang.String, java.time.LocalDateTime> {	1✔
254
255	@Override
256	public java.time.LocalDateTime convert(java.lang.String input) {
257	try {
258	return java.time.LocalDateTime.parse(input);	1✔
259	} catch (DateTimeParseException ignore) {	1✔
260	throw new IllegalTypeException();	1✔
261	}
262	}
263	}
264
265	public static class Boolean extends BaseFormatter<java.lang.Boolean, java.lang.Boolean> {	1✔
266	@Override
267	public java.lang.Boolean convert(java.lang.Boolean input) {
268	return input;	1✔
269	}
270	}
271	}

leeonky / test-charm-java / 206

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