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