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