1
2
3
4
5
6
7
8
9
10
11
12
13
14
15
16
17 package org.apache.commons.lang3.math;
18
19 import static org.apache.commons.lang3.LangAssertions.assertIllegalArgumentException;
20 import static org.apache.commons.lang3.LangAssertions.assertNullPointerException;
21 import static org.junit.jupiter.api.Assertions.assertEquals;
22 import static org.junit.jupiter.api.Assertions.assertFalse;
23 import static org.junit.jupiter.api.Assertions.assertInstanceOf;
24 import static org.junit.jupiter.api.Assertions.assertNotNull;
25 import static org.junit.jupiter.api.Assertions.assertNull;
26 import static org.junit.jupiter.api.Assertions.assertThrows;
27 import static org.junit.jupiter.api.Assertions.assertTrue;
28
29 import java.lang.reflect.Constructor;
30 import java.lang.reflect.Modifier;
31 import java.math.BigDecimal;
32 import java.math.BigInteger;
33 import java.math.RoundingMode;
34 import java.text.NumberFormat;
35 import java.text.ParseException;
36 import java.util.function.Function;
37
38 import org.apache.commons.lang3.AbstractLangTest;
39 import org.apache.commons.lang3.SystemProperties;
40 import org.junit.jupiter.api.Test;
41 import org.junit.jupiter.params.ParameterizedTest;
42 import org.junit.jupiter.params.provider.ValueSource;
43
44
45
46
47 class NumberUtilsTest extends AbstractLangTest {
48
49 private static void assertCreateNumberZero(final String number, final Object zero, final Object negativeZero) {
50 assertEquals(zero, NumberUtils.createNumber(number), () -> "Input: " + number);
51 assertEquals(zero, NumberUtils.createNumber("+" + number), () -> "Input: +" + number);
52 assertEquals(negativeZero, NumberUtils.createNumber("-" + number), () -> "Input: -" + number);
53 }
54
55 private boolean checkCreateNumber(final String val) {
56 try {
57 final Object obj = NumberUtils.createNumber(val);
58 return obj != null;
59 } catch (final NumberFormatException e) {
60 return false;
61 }
62 }
63
64 @Test
65 public void compareByte() {
66 assertTrue(NumberUtils.compare((byte) -3, (byte) 0) < 0);
67 assertEquals(0, NumberUtils.compare((byte) 113, (byte) 113));
68 assertTrue(NumberUtils.compare((byte) 123, (byte) 32) > 0);
69 }
70
71 @Test
72 public void compareInt() {
73 assertTrue(NumberUtils.compare(-3, 0) < 0);
74 assertEquals(0, NumberUtils.compare(113, 113));
75 assertTrue(NumberUtils.compare(213, 32) > 0);
76 }
77
78 private void compareIsCreatableWithCreateNumber(final String val, final boolean expected) {
79 final boolean isValid = NumberUtils.isCreatable(val);
80 final boolean canCreate = checkCreateNumber(val);
81 assertTrue(isValid == expected && canCreate == expected, "Expecting " + expected
82 + " for isCreatable/createNumber using \"" + val + "\" but got " + isValid + " and " + canCreate);
83 }
84
85 @SuppressWarnings("deprecation")
86 private void compareIsNumberWithCreateNumber(final String val, final boolean expected) {
87 final boolean isValid = NumberUtils.isNumber(val);
88 final boolean canCreate = checkCreateNumber(val);
89 assertTrue(isValid == expected && canCreate == expected, "Expecting " + expected
90 + " for isNumber/createNumber using \"" + val + "\" but got " + isValid + " and " + canCreate);
91 }
92
93 @Test
94 public void compareLong() {
95 assertTrue(NumberUtils.compare(-3L, 0L) < 0);
96 assertEquals(0, NumberUtils.compare(113L, 113L));
97 assertTrue(NumberUtils.compare(213L, 32L) > 0);
98 }
99
100 @Test
101 public void compareShort() {
102 assertTrue(NumberUtils.compare((short) -3, (short) 0) < 0);
103 assertEquals(0, NumberUtils.compare((short) 113, (short) 113));
104 assertTrue(NumberUtils.compare((short) 213, (short) 32) > 0);
105 }
106
107 private boolean isApplyNonNull(final String s, final Function<String, ?> function) {
108 try {
109 assertNotNull(function.apply(s));
110 return true;
111 } catch (final Exception e) {
112 if (!s.matches(".*\\s.*") && SystemProperties.getBoolean(getClass(), "printStackTrace", () -> false)) {
113 e.printStackTrace();
114 }
115 return false;
116 }
117 }
118
119 private boolean isNumberFormatParsable(final String s) {
120 final NumberFormat instance = NumberFormat.getInstance();
121 try {
122
123 assertNotNull(instance.parse(s));
124 return true;
125 } catch (final ParseException e) {
126 return false;
127 }
128 }
129
130 private boolean isNumberIntegerOnlyFormatParsable(final String s) {
131 final NumberFormat instance = NumberFormat.getInstance();
132 instance.setParseIntegerOnly(true);
133 try {
134
135 assertNotNull(instance.parse(s));
136 return true;
137 } catch (final ParseException e) {
138 return false;
139 }
140 }
141
142 private boolean isParsableByte(final String s) {
143 final boolean parsable = NumberUtils.isParsable(s);
144 assertTrue(isNumberFormatParsable(s), s);
145 assertTrue(isNumberIntegerOnlyFormatParsable(s), s);
146 assertEquals(parsable, isApplyNonNull(s, Byte::parseByte), s);
147 return parsable;
148 }
149
150 private boolean isParsableDouble(final String s) {
151 final boolean parsable = NumberUtils.isParsable(s);
152 assertTrue(isNumberFormatParsable(s), s);
153 assertTrue(isNumberIntegerOnlyFormatParsable(s), s);
154 assertEquals(parsable, isApplyNonNull(s, Double::parseDouble), s);
155 return parsable;
156 }
157
158 private boolean isParsableFloat(final String s) {
159 final boolean parsable = NumberUtils.isParsable(s);
160 assertTrue(isNumberFormatParsable(s), s);
161 assertTrue(isNumberIntegerOnlyFormatParsable(s), s);
162 assertEquals(parsable, isApplyNonNull(s, Float::parseFloat), s);
163 return parsable;
164 }
165
166 private boolean isParsableInteger(final String s) {
167 final boolean parsable = NumberUtils.isParsable(s);
168 assertTrue(isNumberFormatParsable(s), s);
169 assertTrue(isNumberIntegerOnlyFormatParsable(s), s);
170 assertEquals(parsable, isApplyNonNull(s, Integer::parseInt), s);
171 return parsable;
172 }
173
174 private boolean isParsableLong(final String s) {
175 final boolean parsable = NumberUtils.isParsable(s);
176 assertTrue(isNumberFormatParsable(s), s);
177 assertTrue(isNumberIntegerOnlyFormatParsable(s), s);
178 assertEquals(parsable, isApplyNonNull(s, Long::parseLong), s);
179 return parsable;
180 }
181
182 private boolean isParsableShort(final String s) {
183 final boolean parsable = NumberUtils.isParsable(s);
184 assertTrue(isNumberFormatParsable(s), s);
185 assertTrue(isNumberIntegerOnlyFormatParsable(s), s);
186 assertEquals(parsable, isApplyNonNull(s, Short::parseShort), s);
187 return parsable;
188 }
189
190
191
192
193 @Test
194 void testBigIntegerToDoubleBigInteger() {
195 assertEquals(0.0d, NumberUtils.toDouble((BigDecimal) null), "toDouble(BigInteger) 1 failed");
196 assertEquals(8.5d, NumberUtils.toDouble(BigDecimal.valueOf(8.5d)), "toDouble(BigInteger) 2 failed");
197 }
198
199
200
201
202 @Test
203 void testBigIntegerToDoubleBigIntegerD() {
204 assertEquals(1.1d, NumberUtils.toDouble((BigDecimal) null, 1.1d), "toDouble(BigInteger) 1 failed");
205 assertEquals(8.5d, NumberUtils.toDouble(BigDecimal.valueOf(8.5d), 1.1d), "toDouble(BigInteger) 2 failed");
206 }
207
208
209 @Test
210 void testCompareDouble() {
211 assertEquals(0, Double.compare(Double.NaN, Double.NaN));
212 assertEquals(Double.compare(Double.NaN, Double.POSITIVE_INFINITY), +1);
213 assertEquals(Double.compare(Double.NaN, Double.MAX_VALUE), +1);
214 assertEquals(Double.compare(Double.NaN, 1.2d), +1);
215 assertEquals(Double.compare(Double.NaN, 0.0d), +1);
216 assertEquals(Double.compare(Double.NaN, -0.0d), +1);
217 assertEquals(Double.compare(Double.NaN, -1.2d), +1);
218 assertEquals(Double.compare(Double.NaN, -Double.MAX_VALUE), +1);
219 assertEquals(Double.compare(Double.NaN, Double.NEGATIVE_INFINITY), +1);
220
221 assertEquals(Double.compare(Double.POSITIVE_INFINITY, Double.NaN), -1);
222 assertEquals(0, Double.compare(Double.POSITIVE_INFINITY, Double.POSITIVE_INFINITY));
223 assertEquals(Double.compare(Double.POSITIVE_INFINITY, Double.MAX_VALUE), +1);
224 assertEquals(Double.compare(Double.POSITIVE_INFINITY, 1.2d), +1);
225 assertEquals(Double.compare(Double.POSITIVE_INFINITY, 0.0d), +1);
226 assertEquals(Double.compare(Double.POSITIVE_INFINITY, -0.0d), +1);
227 assertEquals(Double.compare(Double.POSITIVE_INFINITY, -1.2d), +1);
228 assertEquals(Double.compare(Double.POSITIVE_INFINITY, -Double.MAX_VALUE), +1);
229 assertEquals(Double.compare(Double.POSITIVE_INFINITY, Double.NEGATIVE_INFINITY), +1);
230
231 assertEquals(Double.compare(Double.MAX_VALUE, Double.NaN), -1);
232 assertEquals(Double.compare(Double.MAX_VALUE, Double.POSITIVE_INFINITY), -1);
233 assertEquals(0, Double.compare(Double.MAX_VALUE, Double.MAX_VALUE));
234 assertEquals(Double.compare(Double.MAX_VALUE, 1.2d), +1);
235 assertEquals(Double.compare(Double.MAX_VALUE, 0.0d), +1);
236 assertEquals(Double.compare(Double.MAX_VALUE, -0.0d), +1);
237 assertEquals(Double.compare(Double.MAX_VALUE, -1.2d), +1);
238 assertEquals(Double.compare(Double.MAX_VALUE, -Double.MAX_VALUE), +1);
239 assertEquals(Double.compare(Double.MAX_VALUE, Double.NEGATIVE_INFINITY), +1);
240
241 assertEquals(Double.compare(1.2d, Double.NaN), -1);
242 assertEquals(Double.compare(1.2d, Double.POSITIVE_INFINITY), -1);
243 assertEquals(Double.compare(1.2d, Double.MAX_VALUE), -1);
244 assertEquals(0, Double.compare(1.2d, 1.2d));
245 assertEquals(Double.compare(1.2d, 0.0d), +1);
246 assertEquals(Double.compare(1.2d, -0.0d), +1);
247 assertEquals(Double.compare(1.2d, -1.2d), +1);
248 assertEquals(Double.compare(1.2d, -Double.MAX_VALUE), +1);
249 assertEquals(Double.compare(1.2d, Double.NEGATIVE_INFINITY), +1);
250
251 assertEquals(Double.compare(0.0d, Double.NaN), -1);
252 assertEquals(Double.compare(0.0d, Double.POSITIVE_INFINITY), -1);
253 assertEquals(Double.compare(0.0d, Double.MAX_VALUE), -1);
254 assertEquals(Double.compare(0.0d, 1.2d), -1);
255 assertEquals(0, Double.compare(0.0d, 0.0d));
256 assertEquals(Double.compare(0.0d, -0.0d), +1);
257 assertEquals(Double.compare(0.0d, -1.2d), +1);
258 assertEquals(Double.compare(0.0d, -Double.MAX_VALUE), +1);
259 assertEquals(Double.compare(0.0d, Double.NEGATIVE_INFINITY), +1);
260
261 assertEquals(Double.compare(-0.0d, Double.NaN), -1);
262 assertEquals(Double.compare(-0.0d, Double.POSITIVE_INFINITY), -1);
263 assertEquals(Double.compare(-0.0d, Double.MAX_VALUE), -1);
264 assertEquals(Double.compare(-0.0d, 1.2d), -1);
265 assertEquals(Double.compare(-0.0d, 0.0d), -1);
266 assertEquals(0, Double.compare(-0.0d, -0.0d));
267 assertEquals(Double.compare(-0.0d, -1.2d), +1);
268 assertEquals(Double.compare(-0.0d, -Double.MAX_VALUE), +1);
269 assertEquals(Double.compare(-0.0d, Double.NEGATIVE_INFINITY), +1);
270
271 assertEquals(Double.compare(-1.2d, Double.NaN), -1);
272 assertEquals(Double.compare(-1.2d, Double.POSITIVE_INFINITY), -1);
273 assertEquals(Double.compare(-1.2d, Double.MAX_VALUE), -1);
274 assertEquals(Double.compare(-1.2d, 1.2d), -1);
275 assertEquals(Double.compare(-1.2d, 0.0d), -1);
276 assertEquals(Double.compare(-1.2d, -0.0d), -1);
277 assertEquals(0, Double.compare(-1.2d, -1.2d));
278 assertEquals(Double.compare(-1.2d, -Double.MAX_VALUE), +1);
279 assertEquals(Double.compare(-1.2d, Double.NEGATIVE_INFINITY), +1);
280
281 assertEquals(Double.compare(-Double.MAX_VALUE, Double.NaN), -1);
282 assertEquals(Double.compare(-Double.MAX_VALUE, Double.POSITIVE_INFINITY), -1);
283 assertEquals(Double.compare(-Double.MAX_VALUE, Double.MAX_VALUE), -1);
284 assertEquals(Double.compare(-Double.MAX_VALUE, 1.2d), -1);
285 assertEquals(Double.compare(-Double.MAX_VALUE, 0.0d), -1);
286 assertEquals(Double.compare(-Double.MAX_VALUE, -0.0d), -1);
287 assertEquals(Double.compare(-Double.MAX_VALUE, -1.2d), -1);
288 assertEquals(0, Double.compare(-Double.MAX_VALUE, -Double.MAX_VALUE));
289 assertEquals(Double.compare(-Double.MAX_VALUE, Double.NEGATIVE_INFINITY), +1);
290
291 assertEquals(Double.compare(Double.NEGATIVE_INFINITY, Double.NaN), -1);
292 assertEquals(Double.compare(Double.NEGATIVE_INFINITY, Double.POSITIVE_INFINITY), -1);
293 assertEquals(Double.compare(Double.NEGATIVE_INFINITY, Double.MAX_VALUE), -1);
294 assertEquals(Double.compare(Double.NEGATIVE_INFINITY, 1.2d), -1);
295 assertEquals(Double.compare(Double.NEGATIVE_INFINITY, 0.0d), -1);
296 assertEquals(Double.compare(Double.NEGATIVE_INFINITY, -0.0d), -1);
297 assertEquals(Double.compare(Double.NEGATIVE_INFINITY, -1.2d), -1);
298 assertEquals(Double.compare(Double.NEGATIVE_INFINITY, -Double.MAX_VALUE), -1);
299 assertEquals(0, Double.compare(Double.NEGATIVE_INFINITY, Double.NEGATIVE_INFINITY));
300 }
301
302 @Test
303 void testCompareFloat() {
304 assertEquals(0, Float.compare(Float.NaN, Float.NaN));
305 assertEquals(Float.compare(Float.NaN, Float.POSITIVE_INFINITY), +1);
306 assertEquals(Float.compare(Float.NaN, Float.MAX_VALUE), +1);
307 assertEquals(Float.compare(Float.NaN, 1.2f), +1);
308 assertEquals(Float.compare(Float.NaN, 0.0f), +1);
309 assertEquals(Float.compare(Float.NaN, -0.0f), +1);
310 assertEquals(Float.compare(Float.NaN, -1.2f), +1);
311 assertEquals(Float.compare(Float.NaN, -Float.MAX_VALUE), +1);
312 assertEquals(Float.compare(Float.NaN, Float.NEGATIVE_INFINITY), +1);
313
314 assertEquals(Float.compare(Float.POSITIVE_INFINITY, Float.NaN), -1);
315 assertEquals(0, Float.compare(Float.POSITIVE_INFINITY, Float.POSITIVE_INFINITY));
316 assertEquals(Float.compare(Float.POSITIVE_INFINITY, Float.MAX_VALUE), +1);
317 assertEquals(Float.compare(Float.POSITIVE_INFINITY, 1.2f), +1);
318 assertEquals(Float.compare(Float.POSITIVE_INFINITY, 0.0f), +1);
319 assertEquals(Float.compare(Float.POSITIVE_INFINITY, -0.0f), +1);
320 assertEquals(Float.compare(Float.POSITIVE_INFINITY, -1.2f), +1);
321 assertEquals(Float.compare(Float.POSITIVE_INFINITY, -Float.MAX_VALUE), +1);
322 assertEquals(Float.compare(Float.POSITIVE_INFINITY, Float.NEGATIVE_INFINITY), +1);
323
324 assertEquals(Float.compare(Float.MAX_VALUE, Float.NaN), -1);
325 assertEquals(Float.compare(Float.MAX_VALUE, Float.POSITIVE_INFINITY), -1);
326 assertEquals(0, Float.compare(Float.MAX_VALUE, Float.MAX_VALUE));
327 assertEquals(Float.compare(Float.MAX_VALUE, 1.2f), +1);
328 assertEquals(Float.compare(Float.MAX_VALUE, 0.0f), +1);
329 assertEquals(Float.compare(Float.MAX_VALUE, -0.0f), +1);
330 assertEquals(Float.compare(Float.MAX_VALUE, -1.2f), +1);
331 assertEquals(Float.compare(Float.MAX_VALUE, -Float.MAX_VALUE), +1);
332 assertEquals(Float.compare(Float.MAX_VALUE, Float.NEGATIVE_INFINITY), +1);
333
334 assertEquals(Float.compare(1.2f, Float.NaN), -1);
335 assertEquals(Float.compare(1.2f, Float.POSITIVE_INFINITY), -1);
336 assertEquals(Float.compare(1.2f, Float.MAX_VALUE), -1);
337 assertEquals(0, Float.compare(1.2f, 1.2f));
338 assertEquals(Float.compare(1.2f, 0.0f), +1);
339 assertEquals(Float.compare(1.2f, -0.0f), +1);
340 assertEquals(Float.compare(1.2f, -1.2f), +1);
341 assertEquals(Float.compare(1.2f, -Float.MAX_VALUE), +1);
342 assertEquals(Float.compare(1.2f, Float.NEGATIVE_INFINITY), +1);
343
344 assertEquals(Float.compare(0.0f, Float.NaN), -1);
345 assertEquals(Float.compare(0.0f, Float.POSITIVE_INFINITY), -1);
346 assertEquals(Float.compare(0.0f, Float.MAX_VALUE), -1);
347 assertEquals(Float.compare(0.0f, 1.2f), -1);
348 assertEquals(0, Float.compare(0.0f, 0.0f));
349 assertEquals(Float.compare(0.0f, -0.0f), +1);
350 assertEquals(Float.compare(0.0f, -1.2f), +1);
351 assertEquals(Float.compare(0.0f, -Float.MAX_VALUE), +1);
352 assertEquals(Float.compare(0.0f, Float.NEGATIVE_INFINITY), +1);
353
354 assertEquals(Float.compare(-0.0f, Float.NaN), -1);
355 assertEquals(Float.compare(-0.0f, Float.POSITIVE_INFINITY), -1);
356 assertEquals(Float.compare(-0.0f, Float.MAX_VALUE), -1);
357 assertEquals(Float.compare(-0.0f, 1.2f), -1);
358 assertEquals(Float.compare(-0.0f, 0.0f), -1);
359 assertEquals(0, Float.compare(-0.0f, -0.0f));
360 assertEquals(Float.compare(-0.0f, -1.2f), +1);
361 assertEquals(Float.compare(-0.0f, -Float.MAX_VALUE), +1);
362 assertEquals(Float.compare(-0.0f, Float.NEGATIVE_INFINITY), +1);
363
364 assertEquals(Float.compare(-1.2f, Float.NaN), -1);
365 assertEquals(Float.compare(-1.2f, Float.POSITIVE_INFINITY), -1);
366 assertEquals(Float.compare(-1.2f, Float.MAX_VALUE), -1);
367 assertEquals(Float.compare(-1.2f, 1.2f), -1);
368 assertEquals(Float.compare(-1.2f, 0.0f), -1);
369 assertEquals(Float.compare(-1.2f, -0.0f), -1);
370 assertEquals(0, Float.compare(-1.2f, -1.2f));
371 assertEquals(Float.compare(-1.2f, -Float.MAX_VALUE), +1);
372 assertEquals(Float.compare(-1.2f, Float.NEGATIVE_INFINITY), +1);
373
374 assertEquals(Float.compare(-Float.MAX_VALUE, Float.NaN), -1);
375 assertEquals(Float.compare(-Float.MAX_VALUE, Float.POSITIVE_INFINITY), -1);
376 assertEquals(Float.compare(-Float.MAX_VALUE, Float.MAX_VALUE), -1);
377 assertEquals(Float.compare(-Float.MAX_VALUE, 1.2f), -1);
378 assertEquals(Float.compare(-Float.MAX_VALUE, 0.0f), -1);
379 assertEquals(Float.compare(-Float.MAX_VALUE, -0.0f), -1);
380 assertEquals(Float.compare(-Float.MAX_VALUE, -1.2f), -1);
381 assertEquals(0, Float.compare(-Float.MAX_VALUE, -Float.MAX_VALUE));
382 assertEquals(Float.compare(-Float.MAX_VALUE, Float.NEGATIVE_INFINITY), +1);
383
384 assertEquals(Float.compare(Float.NEGATIVE_INFINITY, Float.NaN), -1);
385 assertEquals(Float.compare(Float.NEGATIVE_INFINITY, Float.POSITIVE_INFINITY), -1);
386 assertEquals(Float.compare(Float.NEGATIVE_INFINITY, Float.MAX_VALUE), -1);
387 assertEquals(Float.compare(Float.NEGATIVE_INFINITY, 1.2f), -1);
388 assertEquals(Float.compare(Float.NEGATIVE_INFINITY, 0.0f), -1);
389 assertEquals(Float.compare(Float.NEGATIVE_INFINITY, -0.0f), -1);
390 assertEquals(Float.compare(Float.NEGATIVE_INFINITY, -1.2f), -1);
391 assertEquals(Float.compare(Float.NEGATIVE_INFINITY, -Float.MAX_VALUE), -1);
392 assertEquals(0, Float.compare(Float.NEGATIVE_INFINITY, Float.NEGATIVE_INFINITY));
393 }
394
395 @SuppressWarnings("cast")
396 @Test
397 void testConstants() {
398 assertInstanceOf(Long.class, NumberUtils.LONG_ZERO);
399 assertInstanceOf(Long.class, NumberUtils.LONG_ONE);
400 assertInstanceOf(Long.class, NumberUtils.LONG_MINUS_ONE);
401 assertInstanceOf(Integer.class, NumberUtils.INTEGER_ZERO);
402 assertInstanceOf(Integer.class, NumberUtils.INTEGER_ONE);
403 assertInstanceOf(Integer.class, NumberUtils.INTEGER_MINUS_ONE);
404 assertInstanceOf(Short.class, NumberUtils.SHORT_ZERO);
405 assertInstanceOf(Short.class, NumberUtils.SHORT_ONE);
406 assertInstanceOf(Short.class, NumberUtils.SHORT_MINUS_ONE);
407 assertInstanceOf(Byte.class, NumberUtils.BYTE_ZERO);
408 assertInstanceOf(Byte.class, NumberUtils.BYTE_ONE);
409 assertInstanceOf(Byte.class, NumberUtils.BYTE_MINUS_ONE);
410 assertInstanceOf(Double.class, NumberUtils.DOUBLE_ZERO);
411 assertInstanceOf(Double.class, NumberUtils.DOUBLE_ONE);
412 assertInstanceOf(Double.class, NumberUtils.DOUBLE_MINUS_ONE);
413 assertInstanceOf(Float.class, NumberUtils.FLOAT_ZERO);
414 assertInstanceOf(Float.class, NumberUtils.FLOAT_ONE);
415 assertInstanceOf(Float.class, NumberUtils.FLOAT_MINUS_ONE);
416
417 assertEquals(0, NumberUtils.LONG_ZERO.longValue());
418 assertEquals(1, NumberUtils.LONG_ONE.longValue());
419 assertEquals(NumberUtils.LONG_MINUS_ONE.longValue(), -1);
420 assertEquals(0, NumberUtils.INTEGER_ZERO.intValue());
421 assertEquals(1, NumberUtils.INTEGER_ONE.intValue());
422 assertEquals(NumberUtils.INTEGER_MINUS_ONE.intValue(), -1);
423 assertEquals(0, NumberUtils.SHORT_ZERO.shortValue());
424 assertEquals(1, NumberUtils.SHORT_ONE.shortValue());
425 assertEquals(NumberUtils.SHORT_MINUS_ONE.shortValue(), -1);
426 assertEquals(0, NumberUtils.BYTE_ZERO.byteValue());
427 assertEquals(1, NumberUtils.BYTE_ONE.byteValue());
428 assertEquals(NumberUtils.BYTE_MINUS_ONE.byteValue(), -1);
429 assertEquals(0.0d, NumberUtils.DOUBLE_ZERO.doubleValue());
430 assertEquals(1.0d, NumberUtils.DOUBLE_ONE.doubleValue());
431 assertEquals(NumberUtils.DOUBLE_MINUS_ONE.doubleValue(), -1.0d);
432 assertEquals(0.0f, NumberUtils.FLOAT_ZERO.floatValue());
433 assertEquals(1.0f, NumberUtils.FLOAT_ONE.floatValue());
434 assertEquals(NumberUtils.FLOAT_MINUS_ONE.floatValue(), -1.0f);
435 }
436
437 @Test
438 void testConstructor() {
439 assertNotNull(new NumberUtils());
440 final Constructor<?>[] cons = NumberUtils.class.getDeclaredConstructors();
441 assertEquals(1, cons.length);
442 assertTrue(Modifier.isPublic(cons[0].getModifiers()));
443 assertTrue(Modifier.isPublic(NumberUtils.class.getModifiers()));
444 assertFalse(Modifier.isFinal(NumberUtils.class.getModifiers()));
445 }
446
447 @Test
448 void testCreateBigDecimal() {
449 assertEquals(new BigDecimal("1234.5"), NumberUtils.createBigDecimal("1234.5"),
450 "createBigDecimal(String) failed");
451 assertNull(NumberUtils.createBigDecimal(null), "createBigDecimal(null) failed");
452 testCreateBigDecimalFailure("");
453 testCreateBigDecimalFailure(" ");
454 testCreateBigDecimalFailure("\b\t\n\f\r");
455
456 testCreateBigDecimalFailure("\u00A0\uFEFF\u000B\u000C\u001C\u001D\u001E\u001F");
457
458 testCreateBigDecimalFailure("-");
459
460 testCreateBigDecimalFailure("--");
461 testCreateBigDecimalFailure("--0");
462
463 testCreateBigDecimalFailure("+");
464
465 testCreateBigDecimalFailure("++");
466 testCreateBigDecimalFailure("++0");
467 }
468
469 protected void testCreateBigDecimalFailure(final String str) {
470 assertThrows(NumberFormatException.class, () -> NumberUtils.createBigDecimal(str),
471 "createBigDecimal(\"" + str + "\") should have failed.");
472 }
473
474 @Test
475 void testCreateBigInteger() {
476 assertEquals(new BigInteger("12345"), NumberUtils.createBigInteger("12345"), "createBigInteger(String) failed");
477 assertNull(NumberUtils.createBigInteger(null), "createBigInteger(null) failed");
478 testCreateBigIntegerFailure("");
479 testCreateBigIntegerFailure(" ");
480 testCreateBigIntegerFailure("\b\t\n\f\r");
481
482 testCreateBigIntegerFailure("\u00A0\uFEFF\u000B\u000C\u001C\u001D\u001E\u001F");
483 assertEquals(new BigInteger("255"), NumberUtils.createBigInteger("0xff"), "createBigInteger(String) failed");
484 assertEquals(new BigInteger("255"), NumberUtils.createBigInteger("0Xff"), "createBigInteger(String) failed");
485 assertEquals(new BigInteger("255"), NumberUtils.createBigInteger("#ff"), "createBigInteger(String) failed");
486 assertEquals(new BigInteger("-255"), NumberUtils.createBigInteger("-0xff"), "createBigInteger(String) failed");
487 assertEquals(new BigInteger("255"), NumberUtils.createBigInteger("0377"), "createBigInteger(String) failed");
488 assertEquals(new BigInteger("-255"), NumberUtils.createBigInteger("-0377"), "createBigInteger(String) failed");
489 assertEquals(new BigInteger("-255"), NumberUtils.createBigInteger("-0377"), "createBigInteger(String) failed");
490 assertEquals(new BigInteger("-0"), NumberUtils.createBigInteger("-0"), "createBigInteger(String) failed");
491 assertEquals(new BigInteger("0"), NumberUtils.createBigInteger("0"), "createBigInteger(String) failed");
492 testCreateBigIntegerFailure("#");
493 testCreateBigIntegerFailure("-#");
494 testCreateBigIntegerFailure("0x");
495 testCreateBigIntegerFailure("-0x");
496
497 assertEquals(new BigInteger("+FFFFFFFFFFFFFFFF", 16), NumberUtils.createBigInteger("+0xFFFFFFFFFFFFFFFF"));
498 assertEquals(new BigInteger("+FFFFFFFFFFFFFFFF", 16), NumberUtils.createBigInteger("+#FFFFFFFFFFFFFFFF"));
499 assertEquals(new BigInteger("+1234567", 8), NumberUtils.createBigInteger("+01234567"));
500 }
501
502 protected void testCreateBigIntegerFailure(final String str) {
503 assertThrows(NumberFormatException.class, () -> NumberUtils.createBigInteger(str),
504 "createBigInteger(\"" + str + "\") should have failed.");
505 }
506
507 @Test
508 void testCreateDouble() {
509 assertEquals(Double.valueOf("1234.5"), NumberUtils.createDouble("1234.5"), "createDouble(String) failed");
510 assertNull(NumberUtils.createDouble(null), "createDouble(null) failed");
511 testCreateDoubleFailure("");
512 testCreateDoubleFailure(" ");
513 testCreateDoubleFailure("\b\t\n\f\r");
514
515 testCreateDoubleFailure("\u00A0\uFEFF\u000B\u000C\u001C\u001D\u001E\u001F");
516 }
517
518 protected void testCreateDoubleFailure(final String str) {
519 assertThrows(NumberFormatException.class, () -> NumberUtils.createDouble(str),
520 "createDouble(\"" + str + "\") should have failed.");
521 }
522
523 @Test
524 void testCreateFloat() {
525 assertEquals(Float.valueOf("1234.5"), NumberUtils.createFloat("1234.5"), "createFloat(String) failed");
526 assertNull(NumberUtils.createFloat(null), "createFloat(null) failed");
527 testCreateFloatFailure("");
528 testCreateFloatFailure(" ");
529 testCreateFloatFailure("\b\t\n\f\r");
530
531 testCreateFloatFailure("\u00A0\uFEFF\u000B\u000C\u001C\u001D\u001E\u001F");
532 }
533
534 protected void testCreateFloatFailure(final String str) {
535 assertThrows(NumberFormatException.class, () -> NumberUtils.createFloat(str),
536 "createFloat(\"" + str + "\") should have failed.");
537 }
538
539 @Test
540 void testCreateInteger() {
541 assertEquals(Integer.valueOf("12345"), NumberUtils.createInteger("12345"), "createInteger(String) failed");
542 assertNull(NumberUtils.createInteger(null), "createInteger(null) failed");
543 testCreateIntegerFailure("");
544 testCreateIntegerFailure(" ");
545 testCreateIntegerFailure("\b\t\n\f\r");
546
547 testCreateIntegerFailure("\u00A0\uFEFF\u000B\u000C\u001C\u001D\u001E\u001F");
548
549 assertEquals(Integer.decode("+0xF"), NumberUtils.createInteger("+0xF"));
550 }
551
552 protected void testCreateIntegerFailure(final String str) {
553 assertThrows(NumberFormatException.class, () -> NumberUtils.createInteger(str),
554 "createInteger(\"" + str + "\") should have failed.");
555 }
556
557 @Test
558 void testCreateLong() {
559 assertEquals(Long.valueOf("12345"), NumberUtils.createLong("12345"), "createLong(String) failed");
560 assertNull(NumberUtils.createLong(null), "createLong(null) failed");
561 testCreateLongFailure("");
562 testCreateLongFailure(" ");
563 testCreateLongFailure("\b\t\n\f\r");
564
565 testCreateLongFailure("\u00A0\uFEFF\u000B\u000C\u001C\u001D\u001E\u001F");
566
567 assertEquals(Long.decode("+0xFFFFFFFF"), NumberUtils.createLong("+0xFFFFFFFF"));
568 }
569
570 protected void testCreateLongFailure(final String str) {
571 assertThrows(NumberFormatException.class, () -> NumberUtils.createLong(str),
572 "createLong(\"" + str + "\") should have failed.");
573 }
574
575 @Test
576 void testCreateNumber() {
577
578 assertEquals(Float.valueOf("1234.5"), NumberUtils.createNumber("1234.5"), "createNumber(String) 1 failed");
579 assertEquals(Integer.valueOf("12345"), NumberUtils.createNumber("12345"), "createNumber(String) 2 failed");
580 assertEquals(Double.valueOf("1234.5"), NumberUtils.createNumber("1234.5D"), "createNumber(String) 3 failed");
581 assertEquals(Double.valueOf("1234.5"), NumberUtils.createNumber("1234.5d"), "createNumber(String) 3 failed");
582 assertEquals(Float.valueOf("1234.5"), NumberUtils.createNumber("1234.5F"), "createNumber(String) 4 failed");
583 assertEquals(Float.valueOf("1234.5"), NumberUtils.createNumber("1234.5f"), "createNumber(String) 4 failed");
584 assertEquals(Long.valueOf(Integer.MAX_VALUE + 1L), NumberUtils.createNumber("" + (Integer.MAX_VALUE + 1L)),
585 "createNumber(String) 5 failed");
586 assertEquals(Long.valueOf(12345), NumberUtils.createNumber("12345L"), "createNumber(String) 6 failed");
587 assertEquals(Long.valueOf(12345), NumberUtils.createNumber("12345l"), "createNumber(String) 6 failed");
588 assertEquals(Float.valueOf("-1234.5"), NumberUtils.createNumber("-1234.5"), "createNumber(String) 7 failed");
589 assertEquals(Integer.valueOf("-12345"), NumberUtils.createNumber("-12345"), "createNumber(String) 8 failed");
590 assertEquals(0xFADE, NumberUtils.createNumber("0xFADE").intValue(), "createNumber(String) 9a failed");
591 assertEquals(0xFADE, NumberUtils.createNumber("0Xfade").intValue(), "createNumber(String) 9b failed");
592 assertEquals(-0xFADE, NumberUtils.createNumber("-0xFADE").intValue(), "createNumber(String) 10a failed");
593 assertEquals(-0xFADE, NumberUtils.createNumber("-0Xfade").intValue(), "createNumber(String) 10b failed");
594 assertEquals(Double.valueOf("1.1E200"), NumberUtils.createNumber("1.1E200"), "createNumber(String) 11 failed");
595 assertEquals(Float.valueOf("1.1E20"), NumberUtils.createNumber("1.1E20"), "createNumber(String) 12 failed");
596 assertEquals(Double.valueOf("-1.1E200"), NumberUtils.createNumber("-1.1E200"),
597 "createNumber(String) 13 failed");
598 assertEquals(Double.valueOf("1.1E-200"), NumberUtils.createNumber("1.1E-200"),
599 "createNumber(String) 14 failed");
600 assertNull(NumberUtils.createNumber(null), "createNumber(null) failed");
601 assertEquals(new BigInteger("12345678901234567890"), NumberUtils.createNumber("12345678901234567890L"),
602 "createNumber(String) failed");
603
604 assertEquals(new BigDecimal("1.1E-700"), NumberUtils.createNumber("1.1E-700F"),
605 "createNumber(String) 15 failed");
606
607 assertEquals(Long.valueOf("10" + Integer.MAX_VALUE), NumberUtils.createNumber("10" + Integer.MAX_VALUE + "L"),
608 "createNumber(String) 16 failed");
609 assertEquals(Long.valueOf("10" + Integer.MAX_VALUE), NumberUtils.createNumber("10" + Integer.MAX_VALUE),
610 "createNumber(String) 17 failed");
611 assertEquals(new BigInteger("10" + Long.MAX_VALUE), NumberUtils.createNumber("10" + Long.MAX_VALUE),
612 "createNumber(String) 18 failed");
613
614
615 assertEquals(Float.valueOf("2."), NumberUtils.createNumber("2."), "createNumber(String) LANG-521 failed");
616
617
618 assertFalse(checkCreateNumber("1eE"), "createNumber(String) succeeded");
619
620
621 assertEquals(Double.valueOf(Double.MAX_VALUE), NumberUtils.createNumber("" + Double.MAX_VALUE),
622 "createNumber(String) LANG-693 failed");
623
624
625
626 final Number bigNum = NumberUtils.createNumber("-1.1E-700F");
627 assertNotNull(bigNum);
628 assertEquals(BigDecimal.class, bigNum.getClass());
629
630
631 assertEquals(Double.valueOf("-160952.54"), NumberUtils.createNumber("-160952.54"),
632 "createNumber(String) LANG-1018 failed");
633
634 assertEquals(Double.valueOf("6264583.33"), NumberUtils.createNumber("6264583.33"),
635 "createNumber(String) LANG-1187 failed");
636
637 assertEquals(Double.valueOf("193343.82"), NumberUtils.createNumber("193343.82"),
638 "createNumber(String) LANG-1215 failed");
639
640 assertEquals(Double.valueOf("001234.5678"), NumberUtils.createNumber("001234.5678"),
641 "createNumber(String) LANG-1060a failed");
642 assertEquals(Double.valueOf("+001234.5678"), NumberUtils.createNumber("+001234.5678"),
643 "createNumber(String) LANG-1060b failed");
644 assertEquals(Double.valueOf("-001234.5678"), NumberUtils.createNumber("-001234.5678"),
645 "createNumber(String) LANG-1060c failed");
646 assertEquals(Double.valueOf("0000.00000"), NumberUtils.createNumber("0000.00000d"),
647 "createNumber(String) LANG-1060d failed");
648 assertEquals(Float.valueOf("001234.56"), NumberUtils.createNumber("001234.56"),
649 "createNumber(String) LANG-1060e failed");
650 assertEquals(Float.valueOf("+001234.56"), NumberUtils.createNumber("+001234.56"),
651 "createNumber(String) LANG-1060f failed");
652 assertEquals(Float.valueOf("-001234.56"), NumberUtils.createNumber("-001234.56"),
653 "createNumber(String) LANG-1060g failed");
654 assertEquals(Float.valueOf("0000.10"), NumberUtils.createNumber("0000.10"),
655 "createNumber(String) LANG-1060h failed");
656 assertEquals(Float.valueOf("001.1E20"), NumberUtils.createNumber("001.1E20"),
657 "createNumber(String) LANG-1060i failed");
658 assertEquals(Float.valueOf("+001.1E20"), NumberUtils.createNumber("+001.1E20"),
659 "createNumber(String) LANG-1060j failed");
660 assertEquals(Float.valueOf("-001.1E20"), NumberUtils.createNumber("-001.1E20"),
661 "createNumber(String) LANG-1060k failed");
662 assertEquals(Double.valueOf("001.1E200"), NumberUtils.createNumber("001.1E200"),
663 "createNumber(String) LANG-1060l failed");
664 assertEquals(Double.valueOf("+001.1E200"), NumberUtils.createNumber("+001.1E200"),
665 "createNumber(String) LANG-1060m failed");
666 assertEquals(Double.valueOf("-001.1E200"), NumberUtils.createNumber("-001.1E200"),
667 "createNumber(String) LANG-1060n failed");
668
669 assertEquals(Integer.decode("+0xF"), NumberUtils.createNumber("+0xF"),
670 "createNumber(String) LANG-1645a failed");
671 assertEquals(Long.decode("+0xFFFFFFFF"), NumberUtils.createNumber("+0xFFFFFFFF"),
672 "createNumber(String) LANG-1645b failed");
673 assertEquals(new BigInteger("+FFFFFFFFFFFFFFFF", 16), NumberUtils.createNumber("+0xFFFFFFFFFFFFFFFF"),
674 "createNumber(String) LANG-1645c failed");
675 }
676
677 @Test
678
679 void testCreateNumberFailure_1() {
680 assertThrows(NumberFormatException.class, () -> NumberUtils.createNumber("--1.1E-700F"));
681 }
682
683 @Test
684
685 void testCreateNumberFailure_2() {
686 assertThrows(NumberFormatException.class, () -> NumberUtils.createNumber("-1.1E+0-7e00"));
687 }
688
689 @Test
690
691 void testCreateNumberFailure_3() {
692 assertThrows(NumberFormatException.class, () -> NumberUtils.createNumber("-11E+0-7e00"));
693 }
694
695 @Test
696
697 void testCreateNumberFailure_4() {
698 assertThrows(NumberFormatException.class, () -> NumberUtils.createNumber("1eE+00001"));
699 }
700
701 @Test
702
703 void testCreateNumberFailure_5() {
704 assertThrows(NumberFormatException.class, () -> NumberUtils.createNumber("1234.5ff"));
705 }
706
707 @Test
708
709 void testCreateNumberFailure_6() {
710 assertThrows(NumberFormatException.class, () -> NumberUtils.createNumber("1234.5FF"));
711 }
712
713 @Test
714
715 void testCreateNumberFailure_7() {
716 assertThrows(NumberFormatException.class, () -> NumberUtils.createNumber("1234.5dd"));
717 }
718
719 @Test
720
721 void testCreateNumberFailure_8() {
722 assertThrows(NumberFormatException.class, () -> NumberUtils.createNumber("1234.5DD"));
723 }
724
725
726
727 @Test
728 void testCreateNumberMagnitude() {
729
730 assertEquals(Float.valueOf(Float.MAX_VALUE), NumberUtils.createNumber("3.4028235e+38"));
731 assertEquals(Double.valueOf(3.4028236e+38), NumberUtils.createNumber("3.4028236e+38"));
732
733
734 assertEquals(Double.valueOf(Double.MAX_VALUE), NumberUtils.createNumber("1.7976931348623157e+308"));
735
736 assertEquals(new BigDecimal("1.7976931348623159e+308"), NumberUtils.createNumber("1.7976931348623159e+308"));
737
738
739 final Double nonZero1 = Double.valueOf((double) Float.MIN_VALUE / 2);
740 assertEquals(nonZero1, NumberUtils.createNumber(nonZero1.toString()));
741 assertEquals(nonZero1, NumberUtils.createNumber(nonZero1 + "F"));
742
743
744 final BigDecimal nonZero2 = new BigDecimal("4.9e-325");
745 assertEquals(nonZero2, NumberUtils.createNumber("4.9e-325"));
746 assertEquals(nonZero2, NumberUtils.createNumber("4.9e-325D"));
747 final BigDecimal nonZero3 = new BigDecimal("1e-325");
748 assertEquals(nonZero3, NumberUtils.createNumber("1e-325"));
749 assertEquals(nonZero3, NumberUtils.createNumber("1e-325D"));
750 final BigDecimal nonZero4 = new BigDecimal("0.1e-325");
751 assertEquals(nonZero4, NumberUtils.createNumber("0.1e-325"));
752 assertEquals(nonZero4, NumberUtils.createNumber("0.1e-325D"));
753
754 assertEquals(Integer.valueOf(0x12345678), NumberUtils.createNumber("0x12345678"));
755 assertEquals(Long.valueOf(0x123456789L), NumberUtils.createNumber("0x123456789"));
756
757 assertEquals(Long.valueOf(0x7fffffffffffffffL), NumberUtils.createNumber("0x7fffffffffffffff"));
758
759 assertEquals(new BigInteger("7fffffffffffffff0", 16), NumberUtils.createNumber("0x7fffffffffffffff0"));
760
761 assertEquals(Long.valueOf(0x7fffffffffffffffL), NumberUtils.createNumber("#7fffffffffffffff"));
762 assertEquals(new BigInteger("7fffffffffffffff0", 16), NumberUtils.createNumber("#7fffffffffffffff0"));
763
764 assertEquals(Integer.valueOf(017777777777), NumberUtils.createNumber("017777777777"));
765 assertEquals(Long.valueOf(037777777777L), NumberUtils.createNumber("037777777777"));
766
767
768 assertEquals(Long.valueOf(0777777777777777777777L), NumberUtils.createNumber("0777777777777777777777"));
769
770 assertEquals(new BigInteger("1777777777777777777777", 8), NumberUtils.createNumber("01777777777777777777777"));
771 }
772
773
774
775
776 @Test
777 void testCreateNumberZero() {
778
779 assertEquals(Integer.valueOf(0), NumberUtils.createNumber("0"));
780 assertEquals(Integer.valueOf(0), NumberUtils.createNumber("-0"));
781 assertEquals(Long.valueOf(0), NumberUtils.createNumber("0L"));
782 assertEquals(Long.valueOf(0), NumberUtils.createNumber("-0L"));
783
784
785
786
787
788
789 final int[] exponents = {-2345, 0, 13};
790 final String[] zeros = {"0.", ".0", "0.0", "0"};
791 final Float f0 = Float.valueOf(0);
792 final Float fn0 = Float.valueOf(-0F);
793 final Double d0 = Double.valueOf(0);
794 final Double dn0 = Double.valueOf(-0D);
795
796 for (final String zero : zeros) {
797
798
799 if (zero.indexOf('.') != -1) {
800 assertCreateNumberZero(zero, f0, fn0);
801 }
802 for (final int exp : exponents) {
803 assertCreateNumberZero(zero + "e" + exp, f0, fn0);
804 }
805
806 assertCreateNumberZero(zero + "F", f0, fn0);
807 assertCreateNumberZero(zero + "D", d0, dn0);
808 for (final int exp : exponents) {
809 final String number = zero + "e" + exp;
810 assertCreateNumberZero(number + "F", f0, fn0);
811 assertCreateNumberZero(number + "D", d0, dn0);
812 }
813 }
814 }
815
816 @Test
817 void testInvalidNumber() {
818 assertThrows(NumberFormatException.class, () -> NumberUtils.createNumber("E123e.3"));
819 assertThrows(NumberFormatException.class, () -> NumberUtils.createNumber("-"));
820 }
821
822
823
824
825
826 @Test
827 void testIsCreatable() {
828 compareIsCreatableWithCreateNumber("12345", true);
829 compareIsCreatableWithCreateNumber("1234.5", true);
830 compareIsCreatableWithCreateNumber(".12345", true);
831 compareIsCreatableWithCreateNumber("1234E5", true);
832 compareIsCreatableWithCreateNumber("1234E+5", true);
833 compareIsCreatableWithCreateNumber("1234E-5", true);
834 compareIsCreatableWithCreateNumber("123.4E5", true);
835 compareIsCreatableWithCreateNumber("-1234", true);
836 compareIsCreatableWithCreateNumber("-1234.5", true);
837 compareIsCreatableWithCreateNumber("-.12345", true);
838 compareIsCreatableWithCreateNumber("-1234E5", true);
839 compareIsCreatableWithCreateNumber("0", true);
840 compareIsCreatableWithCreateNumber("0.1", true);
841 compareIsCreatableWithCreateNumber("-0", true);
842 compareIsCreatableWithCreateNumber("01234", true);
843 compareIsCreatableWithCreateNumber("-01234", true);
844 compareIsCreatableWithCreateNumber("-0xABC123", true);
845 compareIsCreatableWithCreateNumber("-0x0", true);
846 compareIsCreatableWithCreateNumber("123.4E21D", true);
847 compareIsCreatableWithCreateNumber("-221.23F", true);
848 compareIsCreatableWithCreateNumber("22338L", true);
849
850 compareIsCreatableWithCreateNumber(null, false);
851 compareIsCreatableWithCreateNumber("", false);
852 compareIsCreatableWithCreateNumber(" ", false);
853 compareIsCreatableWithCreateNumber("\r\n\t", false);
854 compareIsCreatableWithCreateNumber("--2.3", false);
855 compareIsCreatableWithCreateNumber(".12.3", false);
856 compareIsCreatableWithCreateNumber("-123E", false);
857 compareIsCreatableWithCreateNumber("-123E+-212", false);
858 compareIsCreatableWithCreateNumber("-123E2.12", false);
859 compareIsCreatableWithCreateNumber("0xGF", false);
860 compareIsCreatableWithCreateNumber("0xFAE-1", false);
861 compareIsCreatableWithCreateNumber(".", false);
862 compareIsCreatableWithCreateNumber("-0ABC123", false);
863 compareIsCreatableWithCreateNumber("123.4E-D", false);
864 compareIsCreatableWithCreateNumber("123.4ED", false);
865 compareIsCreatableWithCreateNumber("1234E5l", false);
866 compareIsCreatableWithCreateNumber("11a", false);
867 compareIsCreatableWithCreateNumber("1a", false);
868 compareIsCreatableWithCreateNumber("a", false);
869 compareIsCreatableWithCreateNumber("11g", false);
870 compareIsCreatableWithCreateNumber("11z", false);
871 compareIsCreatableWithCreateNumber("11def", false);
872 compareIsCreatableWithCreateNumber("11d11", false);
873 compareIsCreatableWithCreateNumber("11 11", false);
874 compareIsCreatableWithCreateNumber(" 1111", false);
875 compareIsCreatableWithCreateNumber("1111 ", false);
876
877 compareIsCreatableWithCreateNumber("2.", true);
878 compareIsCreatableWithCreateNumber("1.1L", false);
879 compareIsCreatableWithCreateNumber("+0xF", true);
880 compareIsCreatableWithCreateNumber("+0xFFFFFFFF", true);
881 compareIsCreatableWithCreateNumber("+0xFFFFFFFFFFFFFFFF", true);
882 compareIsCreatableWithCreateNumber(".0", true);
883 compareIsCreatableWithCreateNumber("0.", true);
884 compareIsCreatableWithCreateNumber("0.D", true);
885 compareIsCreatableWithCreateNumber("0e1", true);
886 compareIsCreatableWithCreateNumber("0e1D", true);
887 compareIsCreatableWithCreateNumber(".D", false);
888 compareIsCreatableWithCreateNumber(".e10", false);
889 compareIsCreatableWithCreateNumber(".e10D", false);
890 }
891
892 @Test
893 void testIsDigits() {
894 assertFalse(NumberUtils.isDigits(null), "isDigits(null) failed");
895 assertFalse(NumberUtils.isDigits(""), "isDigits('') failed");
896 assertTrue(NumberUtils.isDigits("12345"), "isDigits(String) failed");
897 assertFalse(NumberUtils.isDigits("1234.5"), "isDigits(String) neg 1 failed");
898 assertFalse(NumberUtils.isDigits("1ab"), "isDigits(String) neg 3 failed");
899 assertFalse(NumberUtils.isDigits("abc"), "isDigits(String) neg 4 failed");
900 }
901
902
903
904
905
906 @Test
907 void testIsNumber() {
908 compareIsNumberWithCreateNumber("12345", true);
909 compareIsNumberWithCreateNumber("1234.5", true);
910 compareIsNumberWithCreateNumber(".12345", true);
911 compareIsNumberWithCreateNumber("1234E5", true);
912 compareIsNumberWithCreateNumber("1234E+5", true);
913 compareIsNumberWithCreateNumber("1234E-5", true);
914 compareIsNumberWithCreateNumber("123.4E5", true);
915 compareIsNumberWithCreateNumber("-1234", true);
916 compareIsNumberWithCreateNumber("-1234.5", true);
917 compareIsNumberWithCreateNumber("-.12345", true);
918 compareIsNumberWithCreateNumber("-0001.12345", true);
919 compareIsNumberWithCreateNumber("-000.12345", true);
920 compareIsNumberWithCreateNumber("+00.12345", true);
921 compareIsNumberWithCreateNumber("+0002.12345", true);
922 compareIsNumberWithCreateNumber("-1234E5", true);
923 compareIsNumberWithCreateNumber("0", true);
924 compareIsNumberWithCreateNumber("-0", true);
925 compareIsNumberWithCreateNumber("01234", true);
926 compareIsNumberWithCreateNumber("-01234", true);
927 compareIsNumberWithCreateNumber("-0xABC123", true);
928 compareIsNumberWithCreateNumber("-0x0", true);
929 compareIsNumberWithCreateNumber("123.4E21D", true);
930 compareIsNumberWithCreateNumber("-221.23F", true);
931 compareIsNumberWithCreateNumber("22338L", true);
932
933 compareIsNumberWithCreateNumber(null, false);
934 compareIsNumberWithCreateNumber("", false);
935 compareIsNumberWithCreateNumber(" ", false);
936 compareIsNumberWithCreateNumber("\r\n\t", false);
937 compareIsNumberWithCreateNumber("--2.3", false);
938
939 compareIsNumberWithCreateNumber(".12.3", false);
940 compareIsNumberWithCreateNumber("-123E", false);
941 compareIsNumberWithCreateNumber("-123E+-212", false);
942 compareIsNumberWithCreateNumber("-123E2.12", false);
943 compareIsNumberWithCreateNumber("0xGF", false);
944 compareIsNumberWithCreateNumber("0xFAE-1", false);
945 compareIsNumberWithCreateNumber(".", false);
946 compareIsNumberWithCreateNumber("-0ABC123", false);
947 compareIsNumberWithCreateNumber("123.4E-D", false);
948 compareIsNumberWithCreateNumber("123.4ED", false);
949 compareIsNumberWithCreateNumber("+000E.12345", false);
950 compareIsNumberWithCreateNumber("-000E.12345", false);
951 compareIsNumberWithCreateNumber("1234E5l", false);
952 compareIsNumberWithCreateNumber("11a", false);
953 compareIsNumberWithCreateNumber("1a", false);
954 compareIsNumberWithCreateNumber("a", false);
955 compareIsNumberWithCreateNumber("11g", false);
956 compareIsNumberWithCreateNumber("11z", false);
957 compareIsNumberWithCreateNumber("11def", false);
958 compareIsNumberWithCreateNumber("11d11", false);
959 compareIsNumberWithCreateNumber("11 11", false);
960 compareIsNumberWithCreateNumber(" 1111", false);
961 compareIsNumberWithCreateNumber("1111 ", false);
962
963 compareIsNumberWithCreateNumber("2.", true);
964 compareIsNumberWithCreateNumber("1.1L", false);
965 compareIsNumberWithCreateNumber("+0xF", true);
966 compareIsNumberWithCreateNumber("+0xFFFFFFFF", true);
967 compareIsNumberWithCreateNumber("+0xFFFFFFFFFFFFFFFF", true);
968 compareIsNumberWithCreateNumber(".0", true);
969 compareIsNumberWithCreateNumber("0.", true);
970 compareIsNumberWithCreateNumber("0.D", true);
971 compareIsNumberWithCreateNumber("0e1", true);
972 compareIsNumberWithCreateNumber("0e1D", true);
973 compareIsNumberWithCreateNumber(".D", false);
974 compareIsNumberWithCreateNumber(".e10", false);
975 compareIsNumberWithCreateNumber(".e10D", false);
976 }
977
978 @Test
979 void testIsNumberLANG1252() {
980 compareIsNumberWithCreateNumber("+2", true);
981 compareIsNumberWithCreateNumber("+2.0", true);
982 }
983
984 @Test
985 void testIsNumberLANG1385() {
986 compareIsNumberWithCreateNumber("L", false);
987 }
988
989 @Test
990 void testIsNumberLANG971() {
991 compareIsNumberWithCreateNumber("0085", false);
992 compareIsNumberWithCreateNumber("085", false);
993 compareIsNumberWithCreateNumber("08", false);
994 compareIsNumberWithCreateNumber("07", true);
995 compareIsNumberWithCreateNumber("00", true);
996 }
997
998 @Test
999 void testIsNumberLANG972() {
1000 compareIsNumberWithCreateNumber("0xABCD", true);
1001 compareIsNumberWithCreateNumber("0XABCD", true);
1002 }
1003
1004 @Test
1005 void testIsNumberLANG992() {
1006 compareIsNumberWithCreateNumber("0.0", true);
1007 compareIsNumberWithCreateNumber("0.4790", true);
1008 }
1009
1010 @ParameterizedTest
1011
1012 @ValueSource(strings = {
1013
1014 "3.14",
1015 "3.14d",
1016 "3.14D",
1017 ".5",
1018 ".5d",
1019 "5.",
1020 "5.d",
1021 "5d",
1022 "0.0",
1023 "0.0d",
1024
1025 "1.23e10",
1026 "1.23e10d",
1027 "1.23E10",
1028 "1.23e-10",
1029 "1.23e-10d",
1030 "1e5",
1031 "1e5d",
1032 ".5e3",
1033 ".5e3d",
1034
1035 "0x1.8p3",
1036 "0x1.8p3d",
1037 "0x.8p0",
1038 "0x1p-3",
1039 "0x1.fffffffffffffp1023",
1040 "0x1.fffffffffffffp1023d",
1041
1042 "01.5",
1043 "01.5d" })
1044
1045 void testIsParsableDoubleTrue(final String input) {
1046 Double.parseDouble(input);
1047 assertTrue(NumberUtils.isParsable(input));
1048 }
1049
1050 @ParameterizedTest
1051 @ValueSource(strings = { "", "0xC1AB", "65CBA2", "pendro", "64, 2", "64.2.2", "64..", "64L", "-", "--2",
1052
1053 "e5", "1e", "1e+", "1e-", "1ee5", "1e5e5",
1054
1055 "f", "d", "-f", "-d", })
1056 void testIsParsableFalse(final String input) {
1057 assertFalse(NumberUtils.isParsable(input));
1058 }
1059
1060 @ParameterizedTest
1061
1062 @ValueSource(strings = {
1063
1064 "3.14f",
1065 "3.14F",
1066 ".5f",
1067 "5.f",
1068 "5f",
1069 "0.0f",
1070
1071 "1.23e10f",
1072 "1.23E10f",
1073 "1.23e-10f",
1074 "1e5f",
1075 ".5e3f",
1076
1077 "0x1.8p3f",
1078 "0x.8p0f",
1079 "0x1p-3f",
1080 "0x1.fffffep127f",
1081
1082 "01.5f"})
1083
1084 void testIsParsableFloatTrue(final String input) {
1085 Float.parseFloat(input);
1086 assertTrue(NumberUtils.isParsable(input));
1087 }
1088
1089
1090
1091
1092
1093
1094
1095
1096
1097
1098 @Test
1099 void testIsParsableFullWidthUnicodeJDK8326627() {
1100
1101 final String fullWidth123 = "\uFF10\uFF11\uFF12";
1102 assertThrows(NumberFormatException.class, () -> Double.parseDouble(fullWidth123));
1103 assertThrows(NumberFormatException.class, () -> Float.parseFloat(fullWidth123));
1104 assertTrue(NumberUtils.isParsable(fullWidth123));
1105 assertFalse(NumberUtils.isParsable(fullWidth123 + ".0"));
1106 assertFalse(NumberUtils.isParsable("0." + fullWidth123));
1107 }
1108
1109 @Test
1110 void testIsParsableNull() {
1111
1112 assertFalse(NumberUtils.isParsable(null));
1113 }
1114
1115 @ParameterizedTest
1116
1117 @ValueSource(strings = {
1118 "64.",
1119 "-64.",
1120 "64.2",
1121 "64",
1122 "018",
1123 ".18",
1124 "-65",
1125 "-018",
1126 "-018.2",
1127 "-.236",
1128 "2.",
1129 "2.f",
1130 "2.d",
1131 "1.2e-5f",
1132 "1.2e-5d",
1133
1134 "1e5", "1E5", "1.2e5", "1.2E5", "1.2e+5", "1.2e-5", "-1.2e-5", "1e5f", "1e5F", "1e5d", "1e5D",
1135
1136 "2f", "2F", "2d", "2D", "2.0f", "2.0F", "2.0d", "2.0D", "-2.0f", "-2.0d" })
1137
1138 void testIsParsableTrue(final String input) {
1139 assertTrue(NumberUtils.isParsable(input));
1140 }
1141
1142 @Test
1143 void testLang1087() {
1144
1145 assertEquals(Float.class, NumberUtils.createNumber("0.0").getClass());
1146 assertEquals(Float.valueOf("0.0"), NumberUtils.createNumber("0.0"));
1147
1148 assertEquals(Float.class, NumberUtils.createNumber("+0.0").getClass());
1149 assertEquals(Float.valueOf("+0.0"), NumberUtils.createNumber("+0.0"));
1150
1151 assertEquals(Float.class, NumberUtils.createNumber("-0.0").getClass());
1152 assertEquals(Float.valueOf("-0.0"), NumberUtils.createNumber("-0.0"));
1153 }
1154
1155 @Test
1156 void testLANG1252() {
1157 compareIsCreatableWithCreateNumber("+2", true);
1158 compareIsCreatableWithCreateNumber("+2.0", true);
1159 }
1160
1161 @Test
1162 void testLang1729IsParsableByte() {
1163 assertTrue(isParsableByte("1"));
1164 assertFalse(isParsableByte("1 2 3"));
1165 assertTrue(isParsableByte("ï¼ï¼ï¼"));
1166 assertFalse(isParsableByte("ï¼ ï¼ ï¼"));
1167 }
1168
1169 @Test
1170 void testLang1729IsParsableDouble() {
1171 assertTrue(isParsableDouble("1"));
1172 assertTrue(isParsableDouble("1."));
1173 assertTrue(isParsableDouble("1.f"));
1174 assertTrue(isParsableDouble("1.d"));
1175 assertTrue(isParsableDouble("1.0"));
1176 assertFalse(isParsableDouble("1.0."));
1177 assertFalse(isParsableDouble("1 2 3"));
1178 assertFalse(isParsableDouble("ï¼ ï¼ ï¼"));
1179 }
1180
1181 @Test
1182 void testLang1729IsParsableFloat() {
1183 assertTrue(isParsableFloat("1"));
1184 assertTrue(isParsableFloat("1."));
1185 assertTrue(isParsableFloat("1.f"));
1186 assertTrue(isParsableFloat("1.d"));
1187 assertTrue(isParsableFloat("1.0"));
1188 assertFalse(isParsableFloat("1.0."));
1189 assertFalse(isParsableFloat("1 2 3"));
1190 assertFalse(isParsableFloat("ï¼ ï¼ ï¼"));
1191 }
1192
1193 @Test
1194 void testLang1729IsParsableInteger() {
1195 assertTrue(isParsableInteger("1"));
1196 assertFalse(isParsableInteger("1 2 3"));
1197 assertTrue(isParsableInteger("ï¼ï¼ï¼"));
1198 assertFalse(isParsableInteger("ï¼ ï¼ ï¼"));
1199 }
1200
1201 @Test
1202 void testLang1729IsParsableLong() {
1203 assertTrue(isParsableLong("1"));
1204 assertFalse(isParsableLong("1 2 3"));
1205 assertTrue(isParsableLong("ï¼ï¼ï¼"));
1206 assertFalse(isParsableLong("ï¼ ï¼ ï¼"));
1207 }
1208
1209 @Test
1210 void testLang1729IsParsableShort() {
1211 assertTrue(isParsableShort("1"));
1212 assertFalse(isParsableShort("1 2 3"));
1213 assertTrue(isParsableShort("ï¼ï¼ï¼"));
1214 assertFalse(isParsableShort("ï¼ ï¼ ï¼"));
1215 }
1216
1217 @Test
1218 void testLang300() {
1219 NumberUtils.createNumber("-1l");
1220 NumberUtils.createNumber("01l");
1221 NumberUtils.createNumber("1l");
1222 }
1223
1224 @Test
1225 void testLang381() {
1226 assertTrue(Double.isNaN(NumberUtils.min(1.2, 2.5, Double.NaN)));
1227 assertTrue(Double.isNaN(NumberUtils.max(1.2, 2.5, Double.NaN)));
1228 assertTrue(Float.isNaN(NumberUtils.min(1.2f, 2.5f, Float.NaN)));
1229 assertTrue(Float.isNaN(NumberUtils.max(1.2f, 2.5f, Float.NaN)));
1230
1231 final double[] a = {1.2, Double.NaN, 3.7, 27.0, 42.0, Double.NaN};
1232 assertTrue(Double.isNaN(NumberUtils.max(a)));
1233 assertTrue(Double.isNaN(NumberUtils.min(a)));
1234
1235 final double[] b = {Double.NaN, 1.2, Double.NaN, 3.7, 27.0, 42.0, Double.NaN};
1236 assertTrue(Double.isNaN(NumberUtils.max(b)));
1237 assertTrue(Double.isNaN(NumberUtils.min(b)));
1238
1239 final float[] aF = {1.2f, Float.NaN, 3.7f, 27.0f, 42.0f, Float.NaN};
1240 assertTrue(Float.isNaN(NumberUtils.max(aF)));
1241
1242 final float[] bF = {Float.NaN, 1.2f, Float.NaN, 3.7f, 27.0f, 42.0f, Float.NaN};
1243 assertTrue(Float.isNaN(NumberUtils.max(bF)));
1244 }
1245
1246 @Test
1247 public void TestLang747() {
1248 assertEquals(Integer.valueOf(0x8000), NumberUtils.createNumber("0x8000"));
1249 assertEquals(Integer.valueOf(0x80000), NumberUtils.createNumber("0x80000"));
1250 assertEquals(Integer.valueOf(0x800000), NumberUtils.createNumber("0x800000"));
1251 assertEquals(Integer.valueOf(0x8000000), NumberUtils.createNumber("0x8000000"));
1252 assertEquals(Integer.valueOf(0x7FFFFFFF), NumberUtils.createNumber("0x7FFFFFFF"));
1253 assertEquals(Long.valueOf(0x80000000L), NumberUtils.createNumber("0x80000000"));
1254 assertEquals(Long.valueOf(0xFFFFFFFFL), NumberUtils.createNumber("0xFFFFFFFF"));
1255
1256
1257 assertEquals(Integer.valueOf(0x8000000), NumberUtils.createNumber("0x08000000"));
1258 assertEquals(Integer.valueOf(0x7FFFFFFF), NumberUtils.createNumber("0x007FFFFFFF"));
1259 assertEquals(Long.valueOf(0x80000000L), NumberUtils.createNumber("0x080000000"));
1260 assertEquals(Long.valueOf(0xFFFFFFFFL), NumberUtils.createNumber("0x00FFFFFFFF"));
1261
1262 assertEquals(Long.valueOf(0x800000000L), NumberUtils.createNumber("0x800000000"));
1263 assertEquals(Long.valueOf(0x8000000000L), NumberUtils.createNumber("0x8000000000"));
1264 assertEquals(Long.valueOf(0x80000000000L), NumberUtils.createNumber("0x80000000000"));
1265 assertEquals(Long.valueOf(0x800000000000L), NumberUtils.createNumber("0x800000000000"));
1266 assertEquals(Long.valueOf(0x8000000000000L), NumberUtils.createNumber("0x8000000000000"));
1267 assertEquals(Long.valueOf(0x80000000000000L), NumberUtils.createNumber("0x80000000000000"));
1268 assertEquals(Long.valueOf(0x800000000000000L), NumberUtils.createNumber("0x800000000000000"));
1269 assertEquals(Long.valueOf(0x7FFFFFFFFFFFFFFFL), NumberUtils.createNumber("0x7FFFFFFFFFFFFFFF"));
1270
1271 assertEquals(new BigInteger("8000000000000000", 16), NumberUtils.createNumber("0x8000000000000000"));
1272 assertEquals(new BigInteger("FFFFFFFFFFFFFFFF", 16), NumberUtils.createNumber("0xFFFFFFFFFFFFFFFF"));
1273
1274
1275 assertEquals(Long.valueOf(0x80000000000000L), NumberUtils.createNumber("0x00080000000000000"));
1276 assertEquals(Long.valueOf(0x800000000000000L), NumberUtils.createNumber("0x0800000000000000"));
1277 assertEquals(Long.valueOf(0x7FFFFFFFFFFFFFFFL), NumberUtils.createNumber("0x07FFFFFFFFFFFFFFF"));
1278
1279 assertEquals(new BigInteger("8000000000000000", 16), NumberUtils.createNumber("0x00008000000000000000"));
1280 assertEquals(new BigInteger("FFFFFFFFFFFFFFFF", 16), NumberUtils.createNumber("0x0FFFFFFFFFFFFFFFF"));
1281 }
1282
1283 @Test
1284 void testLANG971() {
1285 compareIsCreatableWithCreateNumber("0085", false);
1286 compareIsCreatableWithCreateNumber("085", false);
1287 compareIsCreatableWithCreateNumber("08", false);
1288 compareIsCreatableWithCreateNumber("07", true);
1289 compareIsCreatableWithCreateNumber("00", true);
1290 }
1291
1292 @Test
1293 void testLANG972() {
1294 compareIsCreatableWithCreateNumber("0xABCD", true);
1295 compareIsCreatableWithCreateNumber("0XABCD", true);
1296 }
1297
1298 @Test
1299 void testLANG992() {
1300 compareIsCreatableWithCreateNumber("0.0", true);
1301 compareIsCreatableWithCreateNumber("0.4790", true);
1302 }
1303
1304 @Test
1305 void testMaxByte() {
1306 assertEquals((byte) 5, NumberUtils.max((byte) 5), "max(byte[]) failed for array length 1");
1307 assertEquals((byte) 9, NumberUtils.max((byte) 6, (byte) 9), "max(byte[]) failed for array length 2");
1308 assertEquals((byte) 10, NumberUtils.max((byte) -10, (byte) -5, (byte) 0, (byte) 5, (byte) 10),
1309 "max(byte[]) failed for array length 5");
1310 assertEquals((byte) 10, NumberUtils.max((byte) -10, (byte) -5, (byte) 0, (byte) 5, (byte) 10));
1311 assertEquals((byte) 10, NumberUtils.max((byte) -5, (byte) 0, (byte) 10, (byte) 5, (byte) -10));
1312 }
1313
1314 @Test
1315 void testMaxByte_emptyArray() {
1316 assertIllegalArgumentException(NumberUtils::max);
1317 }
1318
1319 @Test
1320 void testMaxByte_nullArray() {
1321 assertNullPointerException(() -> NumberUtils.max((byte[]) null));
1322 }
1323
1324 @Test
1325 void testMaxDouble() {
1326 assertEquals(5.1d, NumberUtils.max(5.1d), "max(double[]) failed for array length 1");
1327 assertEquals(9.2d, NumberUtils.max(6.3d, 9.2d), "max(double[]) failed for array length 2");
1328 assertEquals(10.4d, NumberUtils.max(-10.5d, -5.6d, 0, 5.7d, 10.4d), "max(double[]) failed for double length 5");
1329 assertEquals(10d, NumberUtils.max(-10d, -5d, 0d, 5d, 10d));
1330 assertEquals(10d, NumberUtils.max(-5d, 0d, 10d, 5d, -10d));
1331 }
1332
1333 @Test
1334 void testMaxDouble_emptyArray() {
1335 assertIllegalArgumentException(NumberUtils::max);
1336 }
1337
1338 @Test
1339 void testMaxDouble_nullArray() {
1340 assertNullPointerException(() -> NumberUtils.max((double[]) null));
1341 }
1342
1343 @Test
1344 void testMaxFloat() {
1345 assertEquals(5.1f, NumberUtils.max(5.1f), "max(float[]) failed for array length 1");
1346 assertEquals(9.2f, NumberUtils.max(6.3f, 9.2f), "max(float[]) failed for array length 2");
1347 assertEquals(10.4f, NumberUtils.max(-10.5f, -5.6f, 0, 5.7f, 10.4f), "max(float[]) failed for float length 5");
1348 assertEquals(10f, NumberUtils.max(-10f, -5f, 0f, 5f, 10f), 0.0001f);
1349 assertEquals(10f, NumberUtils.max(-5f, 0f, 10f, 5f, -10f), 0.0001f);
1350 }
1351
1352 @Test
1353 void testMaxFloat_emptyArray() {
1354 assertIllegalArgumentException(NumberUtils::max);
1355 }
1356
1357 @Test
1358 void testMaxFloat_nullArray() {
1359 assertNullPointerException(() -> NumberUtils.max((float[]) null));
1360 }
1361
1362 @Test
1363 void testMaximumByte() {
1364 final byte low = 123;
1365 final byte mid = 123 + 1;
1366 final byte high = 123 + 2;
1367 assertEquals(high, NumberUtils.max(low, mid, high), "maximum(byte, byte, byte) 1 failed");
1368 assertEquals(high, NumberUtils.max(mid, low, high), "maximum(byte, byte, byte) 2 failed");
1369 assertEquals(high, NumberUtils.max(mid, high, low), "maximum(byte, byte, byte) 3 failed");
1370 assertEquals(high, NumberUtils.max(high, mid, high), "maximum(byte, byte, byte) 4 failed");
1371 }
1372
1373 @Test
1374 void testMaximumDouble() {
1375 final double low = 12.3;
1376 final double mid = 12.3 + 1;
1377 final double high = 12.3 + 2;
1378 assertEquals(high, NumberUtils.max(low, mid, high), 0.0001);
1379 assertEquals(high, NumberUtils.max(mid, low, high), 0.0001);
1380 assertEquals(high, NumberUtils.max(mid, high, low), 0.0001);
1381 assertEquals(mid, NumberUtils.max(low, mid, low), 0.0001);
1382 assertEquals(high, NumberUtils.max(high, mid, high), 0.0001);
1383 }
1384
1385 @Test
1386 void testMaximumFloat() {
1387 final float low = 12.3f;
1388 final float mid = 12.3f + 1;
1389 final float high = 12.3f + 2;
1390 assertEquals(high, NumberUtils.max(low, mid, high), 0.0001f);
1391 assertEquals(high, NumberUtils.max(mid, low, high), 0.0001f);
1392 assertEquals(high, NumberUtils.max(mid, high, low), 0.0001f);
1393 assertEquals(mid, NumberUtils.max(low, mid, low), 0.0001f);
1394 assertEquals(high, NumberUtils.max(high, mid, high), 0.0001f);
1395 }
1396
1397 @Test
1398 void testMaximumInt() {
1399 assertEquals(12345, NumberUtils.max(12345, 12345 - 1, 12345 - 2), "maximum(int, int, int) 1 failed");
1400 assertEquals(12345, NumberUtils.max(12345 - 1, 12345, 12345 - 2), "maximum(int, int, int) 2 failed");
1401 assertEquals(12345, NumberUtils.max(12345 - 1, 12345 - 2, 12345), "maximum(int, int, int) 3 failed");
1402 assertEquals(12345, NumberUtils.max(12345 - 1, 12345, 12345), "maximum(int, int, int) 4 failed");
1403 assertEquals(12345, NumberUtils.max(12345, 12345, 12345), "maximum(int, int, int) 5 failed");
1404 }
1405
1406 @Test
1407 void testMaximumLong() {
1408 assertEquals(12345L, NumberUtils.max(12345L, 12345L - 1L, 12345L - 2L), "maximum(long, long, long) 1 failed");
1409 assertEquals(12345L, NumberUtils.max(12345L - 1L, 12345L, 12345L - 2L), "maximum(long, long, long) 2 failed");
1410 assertEquals(12345L, NumberUtils.max(12345L - 1L, 12345L - 2L, 12345L), "maximum(long, long, long) 3 failed");
1411 assertEquals(12345L, NumberUtils.max(12345L - 1L, 12345L, 12345L), "maximum(long, long, long) 4 failed");
1412 assertEquals(12345L, NumberUtils.max(12345L, 12345L, 12345L), "maximum(long, long, long) 5 failed");
1413 }
1414
1415 @Test
1416 void testMaximumShort() {
1417 final short low = 1234;
1418 final short mid = 1234 + 1;
1419 final short high = 1234 + 2;
1420 assertEquals(high, NumberUtils.max(low, mid, high), "maximum(short, short, short) 1 failed");
1421 assertEquals(high, NumberUtils.max(mid, low, high), "maximum(short, short, short) 2 failed");
1422 assertEquals(high, NumberUtils.max(mid, high, low), "maximum(short, short, short) 3 failed");
1423 assertEquals(high, NumberUtils.max(high, mid, high), "maximum(short, short, short) 4 failed");
1424 }
1425
1426 @Test
1427 void testMaxInt() {
1428 assertEquals(5, NumberUtils.max(5), "max(int[]) failed for array length 1");
1429 assertEquals(9, NumberUtils.max(6, 9), "max(int[]) failed for array length 2");
1430 assertEquals(10, NumberUtils.max(-10, -5, 0, 5, 10), "max(int[]) failed for array length 5");
1431 assertEquals(10, NumberUtils.max(-10, -5, 0, 5, 10));
1432 assertEquals(10, NumberUtils.max(-5, 0, 10, 5, -10));
1433 }
1434
1435 @Test
1436 void testMaxInt_emptyArray() {
1437 assertIllegalArgumentException(NumberUtils::max);
1438 }
1439
1440 @Test
1441 void testMaxInt_nullArray() {
1442 assertNullPointerException(() -> NumberUtils.max((int[]) null));
1443 }
1444
1445 @Test
1446 void testMaxLong() {
1447 assertEquals(5L, NumberUtils.max(5L), "max(long[]) failed for array length 1");
1448 assertEquals(9L, NumberUtils.max(6L, 9L), "max(long[]) failed for array length 2");
1449 assertEquals(10L, NumberUtils.max(-10L, -5L, 0L, 5L, 10L), "max(long[]) failed for array length 5");
1450 assertEquals(10L, NumberUtils.max(-10L, -5L, 0L, 5L, 10L));
1451 assertEquals(10L, NumberUtils.max(-5L, 0L, 10L, 5L, -10L));
1452 }
1453
1454 @Test
1455 void testMaxLong_emptyArray() {
1456 assertIllegalArgumentException(NumberUtils::max);
1457 }
1458
1459 @Test
1460 void testMaxLong_nullArray() {
1461 assertNullPointerException(() -> NumberUtils.max((long[]) null));
1462 }
1463
1464 @Test
1465 void testMaxShort() {
1466 assertEquals((short) 5, NumberUtils.max((short) 5), "max(short[]) failed for array length 1");
1467 assertEquals((short) 9, NumberUtils.max((short) 6, (short) 9), "max(short[]) failed for array length 2");
1468 assertEquals((short) 10, NumberUtils.max((short) -10, (short) -5, (short) 0, (short) 5, (short) 10),
1469 "max(short[]) failed for array length 5");
1470 assertEquals((short) 10, NumberUtils.max((short) -10, (short) -5, (short) 0, (short) 5, (short) 10));
1471 assertEquals((short) 10, NumberUtils.max((short) -5, (short) 0, (short) 10, (short) 5, (short) -10));
1472 }
1473
1474 @Test
1475 void testMaxShort_emptyArray() {
1476 assertIllegalArgumentException(NumberUtils::max);
1477 }
1478
1479 @Test
1480 void testMaxShort_nullArray() {
1481 assertNullPointerException(() -> NumberUtils.max((short[]) null));
1482 }
1483
1484 @Test
1485 void testMinByte() {
1486 assertEquals((byte) 5, NumberUtils.min((byte) 5), "min(byte[]) failed for array length 1");
1487 assertEquals((byte) 6, NumberUtils.min((byte) 6, (byte) 9), "min(byte[]) failed for array length 2");
1488
1489 assertEquals((byte) -10, NumberUtils.min((byte) -10, (byte) -5, (byte) 0, (byte) 5, (byte) 10));
1490 assertEquals((byte) -10, NumberUtils.min((byte) -5, (byte) 0, (byte) -10, (byte) 5, (byte) 10));
1491 }
1492
1493 @Test
1494 void testMinByte_emptyArray() {
1495 assertIllegalArgumentException(NumberUtils::min);
1496 }
1497
1498 @Test
1499 void testMinByte_nullArray() {
1500 assertNullPointerException(() -> NumberUtils.min((byte[]) null));
1501 }
1502
1503 @Test
1504 void testMinDouble() {
1505 assertEquals(5.12, NumberUtils.min(5.12), "min(double[]) failed for array length 1");
1506 assertEquals(6.23, NumberUtils.min(6.23, 9.34), "min(double[]) failed for array length 2");
1507 assertEquals(-10.45, NumberUtils.min(-10.45, -5.56, 0, 5.67, 10.78), "min(double[]) failed for array length 5");
1508 assertEquals(-10, NumberUtils.min(-10, -5, 0, 5, 10), 0.0001);
1509 assertEquals(-10, NumberUtils.min(-5, 0, -10, 5, 10), 0.0001);
1510 assertEquals(5.12, NumberUtils.min(6.11, 5.12));
1511 }
1512
1513 @Test
1514 void testMinDouble_emptyArray() {
1515 assertIllegalArgumentException(NumberUtils::min);
1516 }
1517
1518 @Test
1519 void testMinDouble_nullArray() {
1520 assertNullPointerException(() -> NumberUtils.min((double[]) null));
1521 }
1522
1523 @Test
1524 void testMinFloat() {
1525 assertEquals(5.9f, NumberUtils.min(5.9f), "min(float[]) failed for array length 1");
1526 assertEquals(6.8f, NumberUtils.min(6.8f, 9.7f), "min(float[]) failed for array length 2");
1527 assertEquals(-10.6f, NumberUtils.min(-10.6f, -5.5f, 0, 5.4f, 10.3f), "min(float[]) failed for array length 5");
1528 assertEquals(-10, NumberUtils.min(-10, -5, 0, 5, 10), 0.0001f);
1529 assertEquals(-10, NumberUtils.min(-5, 0, -10, 5, 10), 0.0001f);
1530 assertEquals(Float.NaN, NumberUtils.min(6.8f, Float.NaN));
1531 assertEquals(3.7f, NumberUtils.min(6.8f, 3.7f));
1532 }
1533
1534 @Test
1535 void testMinFloat_emptyArray() {
1536 assertIllegalArgumentException(NumberUtils::min);
1537 }
1538
1539 @Test
1540 void testMinFloat_nullArray() {
1541 assertNullPointerException(() -> NumberUtils.min((float[]) null));
1542 }
1543
1544 @Test
1545 void testMinimumByte() {
1546 final byte low = 123;
1547 final byte mid = 123 + 1;
1548 final byte high = 123 + 2;
1549 assertEquals(low, NumberUtils.min(low, mid, high), "minimum(byte, byte, byte) 1 failed");
1550 assertEquals(low, NumberUtils.min(mid, low, high), "minimum(byte, byte, byte) 2 failed");
1551 assertEquals(low, NumberUtils.min(mid, high, low), "minimum(byte, byte, byte) 3 failed");
1552 assertEquals(low, NumberUtils.min(low, mid, low), "minimum(byte, byte, byte) 4 failed");
1553 }
1554
1555 @Test
1556 void testMinimumDouble() {
1557 final double low = 12.3;
1558 final double mid = 12.3 + 1;
1559 final double high = 12.3 + 2;
1560 assertEquals(low, NumberUtils.min(low, mid, high), 0.0001);
1561 assertEquals(low, NumberUtils.min(mid, low, high), 0.0001);
1562 assertEquals(low, NumberUtils.min(mid, high, low), 0.0001);
1563 assertEquals(low, NumberUtils.min(low, mid, low), 0.0001);
1564 assertEquals(mid, NumberUtils.min(high, mid, high), 0.0001);
1565 }
1566
1567 @Test
1568 void testMinimumFloat() {
1569 final float low = 12.3f;
1570 final float mid = 12.3f + 1;
1571 final float high = 12.3f + 2;
1572 assertEquals(low, NumberUtils.min(low, mid, high), 0.0001f);
1573 assertEquals(low, NumberUtils.min(mid, low, high), 0.0001f);
1574 assertEquals(low, NumberUtils.min(mid, high, low), 0.0001f);
1575 assertEquals(low, NumberUtils.min(low, mid, low), 0.0001f);
1576 assertEquals(mid, NumberUtils.min(high, mid, high), 0.0001f);
1577 }
1578
1579 @Test
1580 void testMinimumInt() {
1581 assertEquals(12345, NumberUtils.min(12345, 12345 + 1, 12345 + 2), "minimum(int, int, int) 1 failed");
1582 assertEquals(12345, NumberUtils.min(12345 + 1, 12345, 12345 + 2), "minimum(int, int, int) 2 failed");
1583 assertEquals(12345, NumberUtils.min(12345 + 1, 12345 + 2, 12345), "minimum(int, int, int) 3 failed");
1584 assertEquals(12345, NumberUtils.min(12345 + 1, 12345, 12345), "minimum(int, int, int) 4 failed");
1585 assertEquals(12345, NumberUtils.min(12345, 12345, 12345), "minimum(int, int, int) 5 failed");
1586 }
1587
1588 @Test
1589 void testMinimumLong() {
1590 assertEquals(12345L, NumberUtils.min(12345L, 12345L + 1L, 12345L + 2L), "minimum(long, long, long) 1 failed");
1591 assertEquals(12345L, NumberUtils.min(12345L + 1L, 12345L, 12345 + 2L), "minimum(long, long, long) 2 failed");
1592 assertEquals(12345L, NumberUtils.min(12345L + 1L, 12345L + 2L, 12345L), "minimum(long, long, long) 3 failed");
1593 assertEquals(12345L, NumberUtils.min(12345L + 1L, 12345L, 12345L), "minimum(long, long, long) 4 failed");
1594 assertEquals(12345L, NumberUtils.min(12345L, 12345L, 12345L), "minimum(long, long, long) 5 failed");
1595 }
1596
1597 @Test
1598 void testMinimumShort() {
1599 final short low = 1234;
1600 final short mid = 1234 + 1;
1601 final short high = 1234 + 2;
1602 assertEquals(low, NumberUtils.min(low, mid, high), "minimum(short, short, short) 1 failed");
1603 assertEquals(low, NumberUtils.min(mid, low, high), "minimum(short, short, short) 2 failed");
1604 assertEquals(low, NumberUtils.min(mid, high, low), "minimum(short, short, short) 3 failed");
1605 assertEquals(low, NumberUtils.min(low, mid, low), "minimum(short, short, short) 4 failed");
1606 }
1607
1608 @Test
1609 void testMinInt() {
1610 assertEquals(5, NumberUtils.min(5), "min(int[]) failed for array length 1");
1611 assertEquals(6, NumberUtils.min(6, 9), "min(int[]) failed for array length 2");
1612
1613 assertEquals(-10, NumberUtils.min(-10, -5, 0, 5, 10));
1614 assertEquals(-10, NumberUtils.min(-5, 0, -10, 5, 10));
1615 }
1616
1617 @Test
1618 void testMinInt_emptyArray() {
1619 assertIllegalArgumentException(NumberUtils::min);
1620 }
1621
1622 @Test
1623 void testMinInt_nullArray() {
1624 assertNullPointerException(() -> NumberUtils.min((int[]) null));
1625 }
1626
1627 @Test
1628 void testMinLong() {
1629 assertEquals(5L, NumberUtils.min(5L), "min(long[]) failed for array length 1");
1630 assertEquals(6L, NumberUtils.min(6L, 9L), "min(long[]) failed for array length 2");
1631
1632 assertEquals(-10L, NumberUtils.min(-10L, -5L, 0L, 5L, 10L));
1633 assertEquals(-10L, NumberUtils.min(-5L, 0L, -10L, 5L, 10L));
1634 }
1635
1636 @Test
1637 void testMinLong_emptyArray() {
1638 assertIllegalArgumentException(NumberUtils::min);
1639 }
1640
1641 @Test
1642 void testMinLong_nullArray() {
1643 assertNullPointerException(() -> NumberUtils.min((long[]) null));
1644 }
1645
1646 @Test
1647 void testMinShort() {
1648 assertEquals((short) 5, NumberUtils.min((short) 5), "min(short[]) failed for array length 1");
1649 assertEquals((short) 6, NumberUtils.min((short) 6, (short) 9), "min(short[]) failed for array length 2");
1650
1651 assertEquals((short) -10, NumberUtils.min((short) -10, (short) -5, (short) 0, (short) 5, (short) 10));
1652 assertEquals((short) -10, NumberUtils.min((short) -5, (short) 0, (short) -10, (short) 5, (short) 10));
1653 }
1654
1655 @Test
1656 void testMinShort_emptyArray() {
1657 assertIllegalArgumentException(NumberUtils::min);
1658 }
1659
1660 @Test
1661 void testMinShort_nullArray() {
1662 assertNullPointerException(() -> NumberUtils.min((short[]) null));
1663 }
1664
1665
1666
1667
1668 @Test
1669 void testStringCreateNumberEnsureNoPrecisionLoss() {
1670 assertInstanceOf(Float.class, NumberUtils.createNumber("1.23"));
1671 assertInstanceOf(Double.class, NumberUtils.createNumber("3.40282354e+38"));
1672 assertInstanceOf(BigDecimal.class, NumberUtils.createNumber("1.797693134862315759e+308"));
1673
1674 assertInstanceOf(Float.class, NumberUtils.createNumber("001.12"));
1675 assertInstanceOf(Float.class, NumberUtils.createNumber("-001.12"));
1676 assertInstanceOf(Float.class, NumberUtils.createNumber("+001.12"));
1677 assertInstanceOf(Double.class, NumberUtils.createNumber("003.40282354e+38"));
1678 assertInstanceOf(Double.class, NumberUtils.createNumber("-003.40282354e+38"));
1679 assertInstanceOf(Double.class, NumberUtils.createNumber("+003.40282354e+38"));
1680 assertInstanceOf(BigDecimal.class, NumberUtils.createNumber("0001.797693134862315759e+308"));
1681 assertInstanceOf(BigDecimal.class, NumberUtils.createNumber("-001.797693134862315759e+308"));
1682 assertInstanceOf(BigDecimal.class, NumberUtils.createNumber("+001.797693134862315759e+308"));
1683
1684 assertInstanceOf(Double.class, NumberUtils.createNumber("2.2250738585072014E-308"));
1685 assertInstanceOf(Double.class, NumberUtils.createNumber("2.2250738585072014E-308D"));
1686 assertInstanceOf(Double.class, NumberUtils.createNumber("2.2250738585072014E-308F"));
1687 assertInstanceOf(Double.class, NumberUtils.createNumber("4.9E-324"));
1688 assertInstanceOf(Double.class, NumberUtils.createNumber("4.9E-324D"));
1689 assertInstanceOf(Double.class, NumberUtils.createNumber("4.9E-324F"));
1690 assertInstanceOf(Double.class, NumberUtils.createNumber("1.7976931348623157E308"));
1691 assertInstanceOf(Double.class, NumberUtils.createNumber("1.7976931348623157E308D"));
1692 assertInstanceOf(Double.class, NumberUtils.createNumber("1.7976931348623157E308F"));
1693 assertInstanceOf(Double.class, NumberUtils.createNumber("4.9e-324D"));
1694 assertInstanceOf(Double.class, NumberUtils.createNumber("4.9e-324F"));
1695 }
1696
1697
1698
1699
1700 @Test
1701 void testStringToDoubleString() {
1702 assertEquals(NumberUtils.toDouble("-1.2345"), -1.2345d, "toDouble(String) 1 failed");
1703 assertEquals(1.2345d, NumberUtils.toDouble("1.2345"), "toDouble(String) 2 failed");
1704 assertEquals(0.0d, NumberUtils.toDouble("abc"), "toDouble(String) 3 failed");
1705
1706 assertEquals(NumberUtils.toDouble("-001.2345"), -1.2345d, "toDouble(String) 4 failed");
1707 assertEquals(1.2345d, NumberUtils.toDouble("+001.2345"), "toDouble(String) 5 failed");
1708 assertEquals(1.2345d, NumberUtils.toDouble("001.2345"), "toDouble(String) 6 failed");
1709 assertEquals(0d, NumberUtils.toDouble("000.00000"), "toDouble(String) 7 failed");
1710
1711 assertEquals(NumberUtils.toDouble(Double.MAX_VALUE + ""), Double.MAX_VALUE,
1712 "toDouble(Double.MAX_VALUE) failed");
1713 assertEquals(NumberUtils.toDouble(Double.MIN_VALUE + ""), Double.MIN_VALUE,
1714 "toDouble(Double.MIN_VALUE) failed");
1715 assertEquals(0.0d, NumberUtils.toDouble(""), "toDouble(empty) failed");
1716 assertEquals(0.0d, NumberUtils.toDouble((String) null), "toDouble(null) failed");
1717 }
1718
1719
1720
1721
1722 @Test
1723 void testStringToDoubleStringD() {
1724 assertEquals(1.2345d, NumberUtils.toDouble("1.2345", 5.1d), "toDouble(String, int) 1 failed");
1725 assertEquals(5.0d, NumberUtils.toDouble("a", 5.0d), "toDouble(String, int) 2 failed");
1726
1727 assertEquals(1.2345d, NumberUtils.toDouble("001.2345", 5.1d), "toDouble(String, int) 3 failed");
1728 assertEquals(NumberUtils.toDouble("-001.2345", 5.1d), -1.2345d, "toDouble(String, int) 4 failed");
1729 assertEquals(1.2345d, NumberUtils.toDouble("+001.2345", 5.1d), "toDouble(String, int) 5 failed");
1730 assertEquals(0d, NumberUtils.toDouble("000.00", 5.1d), "toDouble(String, int) 7 failed");
1731 assertEquals(5.1d, NumberUtils.toDouble("", 5.1d));
1732 assertEquals(5.1d, NumberUtils.toDouble((String) null, 5.1d));
1733 }
1734
1735
1736
1737
1738 @Test
1739 void testToByteString() {
1740 assertEquals(123, NumberUtils.toByte("123"), "toByte(String) 1 failed");
1741 assertEquals(0, NumberUtils.toByte("abc"), "toByte(String) 2 failed");
1742 assertEquals(0, NumberUtils.toByte(""), "toByte(empty) failed");
1743 assertEquals(0, NumberUtils.toByte(null), "toByte(null) failed");
1744 }
1745
1746
1747
1748
1749 @Test
1750 void testToByteStringI() {
1751 assertEquals(123, NumberUtils.toByte("123", (byte) 5), "toByte(String, byte) 1 failed");
1752 assertEquals(5, NumberUtils.toByte("12.3", (byte) 5), "toByte(String, byte) 2 failed");
1753 assertEquals(5, NumberUtils.toByte("", (byte) 5));
1754 assertEquals(5, NumberUtils.toByte(null, (byte) 5));
1755 }
1756
1757
1758
1759
1760 @Test
1761 void testToFloatString() {
1762 assertEquals(NumberUtils.toFloat("-1.2345"), -1.2345f, "toFloat(String) 1 failed");
1763 assertEquals(1.2345f, NumberUtils.toFloat("1.2345"), "toFloat(String) 2 failed");
1764 assertEquals(0.0f, NumberUtils.toFloat("abc"), "toFloat(String) 3 failed");
1765
1766 assertEquals(NumberUtils.toFloat("-001.2345"), -1.2345f, "toFloat(String) 4 failed");
1767 assertEquals(1.2345f, NumberUtils.toFloat("+001.2345"), "toFloat(String) 5 failed");
1768 assertEquals(1.2345f, NumberUtils.toFloat("001.2345"), "toFloat(String) 6 failed");
1769 assertEquals(0f, NumberUtils.toFloat("000.00"), "toFloat(String) 7 failed");
1770
1771 assertEquals(NumberUtils.toFloat(Float.MAX_VALUE + ""), Float.MAX_VALUE, "toFloat(Float.MAX_VALUE) failed");
1772 assertEquals(NumberUtils.toFloat(Float.MIN_VALUE + ""), Float.MIN_VALUE, "toFloat(Float.MIN_VALUE) failed");
1773 assertEquals(0.0f, NumberUtils.toFloat(""), "toFloat(empty) failed");
1774 assertEquals(0.0f, NumberUtils.toFloat(null), "toFloat(null) failed");
1775 }
1776
1777
1778
1779
1780 @Test
1781 void testToFloatStringF() {
1782 assertEquals(1.2345f, NumberUtils.toFloat("1.2345", 5.1f), "toFloat(String, int) 1 failed");
1783 assertEquals(5.0f, NumberUtils.toFloat("a", 5.0f), "toFloat(String, int) 2 failed");
1784
1785 assertEquals(5.0f, NumberUtils.toFloat("-001Z.2345", 5.0f), "toFloat(String, int) 3 failed");
1786 assertEquals(5.0f, NumberUtils.toFloat("+001AB.2345", 5.0f), "toFloat(String, int) 4 failed");
1787 assertEquals(5.0f, NumberUtils.toFloat("001Z.2345", 5.0f), "toFloat(String, int) 5 failed");
1788 assertEquals(5.0f, NumberUtils.toFloat("", 5.0f));
1789 assertEquals(5.0f, NumberUtils.toFloat(null, 5.0f));
1790 }
1791
1792
1793
1794
1795 @Test
1796 void testToIntString() {
1797 assertEquals(12345, NumberUtils.toInt("12345"), "toInt(String) 1 failed");
1798 assertEquals(0, NumberUtils.toInt("abc"), "toInt(String) 2 failed");
1799 assertEquals(0, NumberUtils.toInt(""), "toInt(empty) failed");
1800 assertEquals(0, NumberUtils.toInt(null), "toInt(null) failed");
1801 }
1802
1803
1804
1805
1806 @Test
1807 void testToIntStringI() {
1808 assertEquals(12345, NumberUtils.toInt("12345", 5), "toInt(String, int) 1 failed");
1809 assertEquals(5, NumberUtils.toInt("1234.5", 5), "toInt(String, int) 2 failed");
1810 assertEquals(5, NumberUtils.toInt("", 5));
1811 assertEquals(5, NumberUtils.toInt(null, 5));
1812 }
1813
1814
1815
1816
1817 @Test
1818 void testToLongString() {
1819 assertEquals(12345L, NumberUtils.toLong("12345"), "toLong(String) 1 failed");
1820 assertEquals(0L, NumberUtils.toLong("abc"), "toLong(String) 2 failed");
1821 assertEquals(0L, NumberUtils.toLong("1L"), "toLong(String) 3 failed");
1822 assertEquals(0L, NumberUtils.toLong("1l"), "toLong(String) 4 failed");
1823 assertEquals(NumberUtils.toLong(Long.MAX_VALUE + ""), Long.MAX_VALUE, "toLong(Long.MAX_VALUE) failed");
1824 assertEquals(NumberUtils.toLong(Long.MIN_VALUE + ""), Long.MIN_VALUE, "toLong(Long.MIN_VALUE) failed");
1825 assertEquals(0L, NumberUtils.toLong(""), "toLong(empty) failed");
1826 assertEquals(0L, NumberUtils.toLong(null), "toLong(null) failed");
1827 }
1828
1829
1830
1831
1832 @Test
1833 void testToLongStringL() {
1834 assertEquals(12345L, NumberUtils.toLong("12345", 5L), "toLong(String, long) 1 failed");
1835 assertEquals(5L, NumberUtils.toLong("1234.5", 5L), "toLong(String, long) 2 failed");
1836 assertEquals(5L, NumberUtils.toLong("", 5L));
1837 assertEquals(5L, NumberUtils.toLong(null, 5L));
1838 }
1839
1840
1841
1842
1843 @Test
1844 void testToScaledBigDecimalBigDecimal() {
1845 assertEquals(NumberUtils.toScaledBigDecimal(BigDecimal.valueOf(123.456)), BigDecimal.valueOf(123.46),
1846 "toScaledBigDecimal(BigDecimal) 1 failed");
1847
1848 assertEquals(NumberUtils.toScaledBigDecimal(BigDecimal.valueOf(23.515)), BigDecimal.valueOf(23.52),
1849 "toScaledBigDecimal(BigDecimal) 2 failed");
1850 assertEquals(NumberUtils.toScaledBigDecimal(BigDecimal.valueOf(23.525)), BigDecimal.valueOf(23.52),
1851 "toScaledBigDecimal(BigDecimal) 3 failed");
1852 assertEquals("2352.00",
1853 NumberUtils.toScaledBigDecimal(BigDecimal.valueOf(23.525)).multiply(BigDecimal.valueOf(100)).toString(),
1854 "toScaledBigDecimal(BigDecimal) 4 failed");
1855 assertEquals(NumberUtils.toScaledBigDecimal((BigDecimal) null), BigDecimal.ZERO,
1856 "toScaledBigDecimal(BigDecimal) 5 failed");
1857 }
1858
1859
1860
1861
1862 @Test
1863 void testToScaledBigDecimalBigDecimalIRM() {
1864 assertEquals(NumberUtils.toScaledBigDecimal(BigDecimal.valueOf(123.456), 1, RoundingMode.CEILING),
1865 BigDecimal.valueOf(123.5), "toScaledBigDecimal(BigDecimal, int, RoundingMode) 1 failed");
1866 assertEquals(NumberUtils.toScaledBigDecimal(BigDecimal.valueOf(23.5159), 3, RoundingMode.FLOOR),
1867 BigDecimal.valueOf(23.515), "toScaledBigDecimal(BigDecimal, int, RoundingMode) 2 failed");
1868 assertEquals(NumberUtils.toScaledBigDecimal(BigDecimal.valueOf(23.525), 2, RoundingMode.HALF_UP),
1869 BigDecimal.valueOf(23.53), "toScaledBigDecimal(BigDecimal, int, RoundingMode) 3 failed");
1870 assertEquals("23521.0000",
1871 NumberUtils.toScaledBigDecimal(BigDecimal.valueOf(23.521), 4, RoundingMode.HALF_EVEN)
1872 .multiply(BigDecimal.valueOf(1000)).toString(),
1873 "toScaledBigDecimal(BigDecimal, int, RoundingMode) 4 failed");
1874 assertEquals(NumberUtils.toScaledBigDecimal((BigDecimal) null, 2, RoundingMode.HALF_UP), BigDecimal.ZERO,
1875 "toScaledBigDecimal(BigDecimal, int, RoundingMode) 5 failed");
1876 }
1877
1878
1879
1880
1881 @Test
1882 void testToScaledBigDecimalDouble() {
1883 assertEquals(NumberUtils.toScaledBigDecimal(Double.valueOf(123.456d)), BigDecimal.valueOf(123.46),
1884 "toScaledBigDecimal(Double) 1 failed");
1885
1886 assertEquals(NumberUtils.toScaledBigDecimal(Double.valueOf(23.515d)), BigDecimal.valueOf(23.52),
1887 "toScaledBigDecimal(Double) 2 failed");
1888 assertEquals(NumberUtils.toScaledBigDecimal(Double.valueOf(23.525d)), BigDecimal.valueOf(23.52),
1889 "toScaledBigDecimal(Double) 3 failed");
1890 assertEquals("2352.00",
1891 NumberUtils.toScaledBigDecimal(Double.valueOf(23.525d)).multiply(BigDecimal.valueOf(100)).toString(),
1892 "toScaledBigDecimal(Double) 4 failed");
1893 assertEquals(NumberUtils.toScaledBigDecimal((Double) null), BigDecimal.ZERO,
1894 "toScaledBigDecimal(Double) 5 failed");
1895 }
1896
1897
1898
1899
1900 @Test
1901 void testToScaledBigDecimalDoubleIRM() {
1902 assertEquals(NumberUtils.toScaledBigDecimal(Double.valueOf(123.456d), 1, RoundingMode.CEILING),
1903 BigDecimal.valueOf(123.5), "toScaledBigDecimal(Double, int, RoundingMode) 1 failed");
1904 assertEquals(NumberUtils.toScaledBigDecimal(Double.valueOf(23.5159d), 3, RoundingMode.FLOOR),
1905 BigDecimal.valueOf(23.515), "toScaledBigDecimal(Double, int, RoundingMode) 2 failed");
1906 assertEquals(NumberUtils.toScaledBigDecimal(Double.valueOf(23.525d), 2, RoundingMode.HALF_UP),
1907 BigDecimal.valueOf(23.53), "toScaledBigDecimal(Double, int, RoundingMode) 3 failed");
1908 assertEquals("23521.0000",
1909 NumberUtils.toScaledBigDecimal(Double.valueOf(23.521d), 4, RoundingMode.HALF_EVEN)
1910 .multiply(BigDecimal.valueOf(1000)).toString(),
1911 "toScaledBigDecimal(Double, int, RoundingMode) 4 failed");
1912 assertEquals(NumberUtils.toScaledBigDecimal((Double) null, 2, RoundingMode.HALF_UP), BigDecimal.ZERO,
1913 "toScaledBigDecimal(Double, int, RoundingMode) 5 failed");
1914 }
1915
1916
1917
1918
1919 @Test
1920 void testToScaledBigDecimalFloat() {
1921 assertEquals(NumberUtils.toScaledBigDecimal(Float.valueOf(123.456f)), BigDecimal.valueOf(123.46),
1922 "toScaledBigDecimal(Float) 1 failed");
1923
1924 assertEquals(NumberUtils.toScaledBigDecimal(Float.valueOf(23.515f)), BigDecimal.valueOf(23.51),
1925 "toScaledBigDecimal(Float) 2 failed");
1926
1927
1928 assertEquals(NumberUtils.toScaledBigDecimal(Float.valueOf(23.525f)), BigDecimal.valueOf(23.52),
1929 "toScaledBigDecimal(Float) 3 failed");
1930 assertEquals("2352.00",
1931 NumberUtils.toScaledBigDecimal(Float.valueOf(23.525f)).multiply(BigDecimal.valueOf(100)).toString(),
1932 "toScaledBigDecimal(Float) 4 failed");
1933 assertEquals(NumberUtils.toScaledBigDecimal((Float) null), BigDecimal.ZERO,
1934 "toScaledBigDecimal(Float) 5 failed");
1935 }
1936
1937
1938
1939
1940 @Test
1941 void testToScaledBigDecimalFloatIRM() {
1942 assertEquals(NumberUtils.toScaledBigDecimal(Float.valueOf(123.456f), 1, RoundingMode.CEILING),
1943 BigDecimal.valueOf(123.5), "toScaledBigDecimal(Float, int, RoundingMode) 1 failed");
1944 assertEquals(NumberUtils.toScaledBigDecimal(Float.valueOf(23.5159f), 3, RoundingMode.FLOOR),
1945 BigDecimal.valueOf(23.515), "toScaledBigDecimal(Float, int, RoundingMode) 2 failed");
1946
1947 assertEquals(NumberUtils.toScaledBigDecimal(Float.valueOf(23.525f), 2, RoundingMode.HALF_UP),
1948 BigDecimal.valueOf(23.52), "toScaledBigDecimal(Float, int, RoundingMode) 3 failed");
1949 assertEquals("23521.0000", NumberUtils.toScaledBigDecimal(Float.valueOf(23.521f), 4, RoundingMode.HALF_EVEN)
1950 .multiply(BigDecimal.valueOf(1000)).toString(), "toScaledBigDecimal(Float, int, RoundingMode) 4 failed");
1951 assertEquals(NumberUtils.toScaledBigDecimal((Float) null, 2, RoundingMode.HALF_UP), BigDecimal.ZERO,
1952 "toScaledBigDecimal(Float, int, RoundingMode) 5 failed");
1953 }
1954
1955
1956
1957
1958 @Test
1959 void testToScaledBigDecimalString() {
1960 assertEquals(NumberUtils.toScaledBigDecimal("123.456"), BigDecimal.valueOf(123.46),
1961 "toScaledBigDecimal(String) 1 failed");
1962
1963 assertEquals(NumberUtils.toScaledBigDecimal("23.515"), BigDecimal.valueOf(23.52),
1964 "toScaledBigDecimal(String) 2 failed");
1965 assertEquals(NumberUtils.toScaledBigDecimal("23.525"), BigDecimal.valueOf(23.52),
1966 "toScaledBigDecimal(String) 3 failed");
1967 assertEquals("2352.00", NumberUtils.toScaledBigDecimal("23.525").multiply(BigDecimal.valueOf(100)).toString(),
1968 "toScaledBigDecimal(String) 4 failed");
1969 assertEquals(NumberUtils.toScaledBigDecimal((String) null), BigDecimal.ZERO,
1970 "toScaledBigDecimal(String) 5 failed");
1971 }
1972
1973
1974
1975
1976 @Test
1977 void testToScaledBigDecimalStringIRM() {
1978 assertEquals(NumberUtils.toScaledBigDecimal("123.456", 1, RoundingMode.CEILING), BigDecimal.valueOf(123.5),
1979 "toScaledBigDecimal(String, int, RoundingMode) 1 failed");
1980 assertEquals(NumberUtils.toScaledBigDecimal("23.5159", 3, RoundingMode.FLOOR), BigDecimal.valueOf(23.515),
1981 "toScaledBigDecimal(String, int, RoundingMode) 2 failed");
1982 assertEquals(NumberUtils.toScaledBigDecimal("23.525", 2, RoundingMode.HALF_UP), BigDecimal.valueOf(23.53),
1983 "toScaledBigDecimal(String, int, RoundingMode) 3 failed");
1984 assertEquals(
1985 "23521.0000", NumberUtils.toScaledBigDecimal("23.521", 4, RoundingMode.HALF_EVEN)
1986 .multiply(BigDecimal.valueOf(1000)).toString(),
1987 "toScaledBigDecimal(String, int, RoundingMode) 4 failed");
1988 assertEquals(NumberUtils.toScaledBigDecimal((String) null, 2, RoundingMode.HALF_UP), BigDecimal.ZERO,
1989 "toScaledBigDecimal(String, int, RoundingMode) 5 failed");
1990 }
1991
1992
1993
1994
1995 @Test
1996 void testToShortString() {
1997 assertEquals(12345, NumberUtils.toShort("12345"), "toShort(String) 1 failed");
1998 assertEquals(0, NumberUtils.toShort("abc"), "toShort(String) 2 failed");
1999 assertEquals(0, NumberUtils.toShort(""), "toShort(empty) failed");
2000 assertEquals(0, NumberUtils.toShort(null), "toShort(null) failed");
2001 }
2002
2003
2004
2005
2006 @Test
2007 void testToShortStringI() {
2008 assertEquals(12345, NumberUtils.toShort("12345", (short) 5), "toShort(String, short) 1 failed");
2009 assertEquals(5, NumberUtils.toShort("1234.5", (short) 5), "toShort(String, short) 2 failed");
2010 assertEquals(5, NumberUtils.toShort("", (short) 5));
2011 assertEquals(5, NumberUtils.toShort(null, (short) 5));
2012 }
2013 }