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 @Test
694
695 void testCreateNumberFailure_1() {
696 assertThrows(NumberFormatException.class, () -> NumberUtils.createNumber("--1.1E-700F"));
697 }
698
699 @Test
700
701 void testCreateNumberFailure_2() {
702 assertThrows(NumberFormatException.class, () -> NumberUtils.createNumber("-1.1E+0-7e00"));
703 }
704
705 @Test
706
707 void testCreateNumberFailure_3() {
708 assertThrows(NumberFormatException.class, () -> NumberUtils.createNumber("-11E+0-7e00"));
709 }
710
711 @Test
712
713 void testCreateNumberFailure_4() {
714 assertThrows(NumberFormatException.class, () -> NumberUtils.createNumber("1eE+00001"));
715 }
716
717 @Test
718
719 void testCreateNumberFailure_5() {
720 assertThrows(NumberFormatException.class, () -> NumberUtils.createNumber("1234.5ff"));
721 }
722
723 @Test
724
725 void testCreateNumberFailure_6() {
726 assertThrows(NumberFormatException.class, () -> NumberUtils.createNumber("1234.5FF"));
727 }
728
729 @Test
730
731 void testCreateNumberFailure_7() {
732 assertThrows(NumberFormatException.class, () -> NumberUtils.createNumber("1234.5dd"));
733 }
734
735 @Test
736
737 void testCreateNumberFailure_8() {
738 assertThrows(NumberFormatException.class, () -> NumberUtils.createNumber("1234.5DD"));
739 }
740
741
742
743
744 @Test
745 void testCreateNumberFailure_9() {
746 assertThrows(NumberFormatException.class, () -> NumberUtils.createNumber("++1L"));
747 assertThrows(NumberFormatException.class, () -> NumberUtils.createNumber("++1l"));
748 assertThrows(NumberFormatException.class, () -> NumberUtils.createNumber("--1L"));
749 assertThrows(NumberFormatException.class, () -> NumberUtils.createNumber("--1l"));
750 assertThrows(NumberFormatException.class, () -> NumberUtils.createNumber("+-1L"));
751 assertThrows(NumberFormatException.class, () -> NumberUtils.createNumber("-+1L"));
752 assertThrows(NumberFormatException.class, () -> NumberUtils.createNumber("+L"));
753 assertThrows(NumberFormatException.class, () -> NumberUtils.createNumber("-L"));
754 }
755
756
757
758 @Test
759 void testCreateNumberMagnitude() {
760
761 assertEquals(Float.valueOf(Float.MAX_VALUE), NumberUtils.createNumber("3.4028235e+38"));
762 assertEquals(Double.valueOf(3.4028236e+38), NumberUtils.createNumber("3.4028236e+38"));
763
764 assertEquals(Double.valueOf(Double.MAX_VALUE), NumberUtils.createNumber("1.7976931348623157e+308"));
765
766 assertEquals(new BigDecimal("1.7976931348623159e+308"), NumberUtils.createNumber("1.7976931348623159e+308"));
767
768 final Double nonZero1 = Double.valueOf((double) Float.MIN_VALUE / 2);
769 assertEquals(nonZero1, NumberUtils.createNumber(nonZero1.toString()));
770 assertEquals(nonZero1, NumberUtils.createNumber(nonZero1 + "F"));
771
772
773 final BigDecimal nonZero2 = new BigDecimal("4.9e-325");
774 assertEquals(nonZero2, NumberUtils.createNumber("4.9e-325"));
775 assertEquals(nonZero2, NumberUtils.createNumber("4.9e-325D"));
776 final BigDecimal nonZero3 = new BigDecimal("1e-325");
777 assertEquals(nonZero3, NumberUtils.createNumber("1e-325"));
778 assertEquals(nonZero3, NumberUtils.createNumber("1e-325D"));
779 final BigDecimal nonZero4 = new BigDecimal("0.1e-325");
780 assertEquals(nonZero4, NumberUtils.createNumber("0.1e-325"));
781 assertEquals(nonZero4, NumberUtils.createNumber("0.1e-325D"));
782 assertEquals(Integer.valueOf(0x12345678), NumberUtils.createNumber("0x12345678"));
783 assertEquals(Long.valueOf(0x123456789L), NumberUtils.createNumber("0x123456789"));
784 assertEquals(Long.valueOf(0x7fffffffffffffffL), NumberUtils.createNumber("0x7fffffffffffffff"));
785
786 assertEquals(new BigInteger("7fffffffffffffff0", 16), NumberUtils.createNumber("0x7fffffffffffffff0"));
787 assertEquals(Long.valueOf(0x7fffffffffffffffL), NumberUtils.createNumber("#7fffffffffffffff"));
788 assertEquals(new BigInteger("7fffffffffffffff0", 16), NumberUtils.createNumber("#7fffffffffffffff0"));
789 assertEquals(Integer.valueOf(017777777777), NumberUtils.createNumber("017777777777"));
790 assertEquals(Long.valueOf(037777777777L), NumberUtils.createNumber("037777777777"));
791
792 assertEquals(Long.valueOf(0777777777777777777777L), NumberUtils.createNumber("0777777777777777777777"));
793
794 assertEquals(new BigInteger("1777777777777777777777", 8), NumberUtils.createNumber("01777777777777777777777"));
795 }
796
797
798
799
800 @Test
801 void testCreateNumberZero() {
802
803 assertEquals(Integer.valueOf(0), NumberUtils.createNumber("0"));
804 assertEquals(Integer.valueOf(0), NumberUtils.createNumber("-0"));
805 assertEquals(Long.valueOf(0), NumberUtils.createNumber("0L"));
806 assertEquals(Long.valueOf(0), NumberUtils.createNumber("-0L"));
807
808
809
810
811 final int[] exponents = { -2345, 0, 13 };
812 final String[] zeros = { "0.", ".0", "0.0", "0" };
813 final Float f0 = Float.valueOf(0);
814 final Float fn0 = Float.valueOf(-0F);
815 final Double d0 = Double.valueOf(0);
816 final Double dn0 = Double.valueOf(-0D);
817 for (final String zero : zeros) {
818
819
820 if (zero.indexOf('.') != -1) {
821 assertCreateNumberZero(zero, f0, fn0);
822 }
823 for (final int exp : exponents) {
824 assertCreateNumberZero(zero + "e" + exp, f0, fn0);
825 }
826
827 assertCreateNumberZero(zero + "F", f0, fn0);
828 assertCreateNumberZero(zero + "D", d0, dn0);
829 for (final int exp : exponents) {
830 final String number = zero + "e" + exp;
831 assertCreateNumberZero(number + "F", f0, fn0);
832 assertCreateNumberZero(number + "D", d0, dn0);
833 }
834 }
835 }
836
837 @Test
838 void testInvalidNumber() {
839 assertThrows(NumberFormatException.class, () -> NumberUtils.createNumber("E123e.3"));
840 assertThrows(NumberFormatException.class, () -> NumberUtils.createNumber("-"));
841 }
842
843
844
845
846 @Test
847 void testIsCreatable() {
848 compareIsCreatableWithCreateNumber("12345", true);
849 compareIsCreatableWithCreateNumber("1234.5", true);
850 compareIsCreatableWithCreateNumber(".12345", true);
851 compareIsCreatableWithCreateNumber("1234E5", true);
852 compareIsCreatableWithCreateNumber("1234E+5", true);
853 compareIsCreatableWithCreateNumber("1234E-5", true);
854 compareIsCreatableWithCreateNumber("123.4E5", true);
855 compareIsCreatableWithCreateNumber("-1234", true);
856 compareIsCreatableWithCreateNumber("-1234.5", true);
857 compareIsCreatableWithCreateNumber("-.12345", true);
858 compareIsCreatableWithCreateNumber("-1234E5", true);
859 compareIsCreatableWithCreateNumber("0", true);
860 compareIsCreatableWithCreateNumber("0.1", true);
861 compareIsCreatableWithCreateNumber("-0", true);
862 compareIsCreatableWithCreateNumber("01234", true);
863 compareIsCreatableWithCreateNumber("-01234", true);
864 compareIsCreatableWithCreateNumber("-0xABC123", true);
865 compareIsCreatableWithCreateNumber("-0x0", true);
866 compareIsCreatableWithCreateNumber("123.4E21D", true);
867 compareIsCreatableWithCreateNumber("-221.23F", true);
868 compareIsCreatableWithCreateNumber("22338L", true);
869 compareIsCreatableWithCreateNumber("+22338L", true);
870 compareIsCreatableWithCreateNumber("+22338l", true);
871 compareIsCreatableWithCreateNumber("+0L", true);
872 compareIsCreatableWithCreateNumber("+0l", true);
873 compareIsCreatableWithCreateNumber("+" + Long.MAX_VALUE + "L", true);
874 compareIsCreatableWithCreateNumber("+" + Long.MAX_VALUE + "l", true);
875 compareIsCreatableWithCreateNumber(Long.MAX_VALUE + "L", true);
876 compareIsCreatableWithCreateNumber(Long.MAX_VALUE + "l", true);
877 compareIsCreatableWithCreateNumber(Long.MIN_VALUE + "L", true);
878 compareIsCreatableWithCreateNumber(Long.MIN_VALUE + "l", true);
879 compareIsCreatableWithCreateNumber("+" + BigInteger.valueOf(Long.MAX_VALUE).add(BigInteger.ONE) + "L", true);
880 compareIsCreatableWithCreateNumber("+" + BigInteger.valueOf(Long.MAX_VALUE).add(BigInteger.ONE) + "l", true);
881 compareIsCreatableWithCreateNumber("+12345678901234567890L", true);
882 compareIsCreatableWithCreateNumber(null, false);
883 compareIsCreatableWithCreateNumber("", false);
884 compareIsCreatableWithCreateNumber(" ", false);
885 compareIsCreatableWithCreateNumber("\r\n\t", false);
886 compareIsCreatableWithCreateNumber("--2.3", false);
887 compareIsCreatableWithCreateNumber("--2", false);
888 compareIsCreatableWithCreateNumber("-+2", false);
889 compareIsCreatableWithCreateNumber("+-2", false);
890 compareIsCreatableWithCreateNumber("++2", false);
891 compareIsCreatableWithCreateNumber("++1L", false);
892 compareIsCreatableWithCreateNumber("++1l", false);
893 compareIsCreatableWithCreateNumber("--1L", false);
894 compareIsCreatableWithCreateNumber("--1l", false);
895 compareIsCreatableWithCreateNumber("+-1L", false);
896 compareIsCreatableWithCreateNumber("-+1L", false);
897 compareIsCreatableWithCreateNumber("+L", false);
898 compareIsCreatableWithCreateNumber("-L", false);
899 compareIsCreatableWithCreateNumber(".12.3", false);
900 compareIsCreatableWithCreateNumber("-123E", false);
901 compareIsCreatableWithCreateNumber("-123E+-212", false);
902 compareIsCreatableWithCreateNumber("-123E2.12", false);
903 compareIsCreatableWithCreateNumber("0xGF", false);
904 compareIsCreatableWithCreateNumber("0xFAE-1", false);
905 compareIsCreatableWithCreateNumber(".", false);
906 compareIsCreatableWithCreateNumber("-0ABC123", false);
907 compareIsCreatableWithCreateNumber("123.4E-D", false);
908 compareIsCreatableWithCreateNumber("123.4ED", false);
909 compareIsCreatableWithCreateNumber("1234E5l", false);
910 compareIsCreatableWithCreateNumber("11a", false);
911 compareIsCreatableWithCreateNumber("1a", false);
912 compareIsCreatableWithCreateNumber("a", false);
913 compareIsCreatableWithCreateNumber("11g", false);
914 compareIsCreatableWithCreateNumber("11z", false);
915 compareIsCreatableWithCreateNumber("11def", false);
916 compareIsCreatableWithCreateNumber("11d11", false);
917 compareIsCreatableWithCreateNumber("11 11", false);
918 compareIsCreatableWithCreateNumber(" 1111", false);
919 compareIsCreatableWithCreateNumber("1111 ", false);
920 compareIsCreatableWithCreateNumber("2.", true);
921 compareIsCreatableWithCreateNumber("1.1L", false);
922 compareIsCreatableWithCreateNumber("+0xF", true);
923 compareIsCreatableWithCreateNumber("+0xFFFFFFFF", true);
924 compareIsCreatableWithCreateNumber("+0xFFFFFFFFFFFFFFFF", true);
925 compareIsCreatableWithCreateNumber(".0", true);
926 compareIsCreatableWithCreateNumber("0.", true);
927 compareIsCreatableWithCreateNumber("0.D", true);
928 compareIsCreatableWithCreateNumber("0e1", true);
929 compareIsCreatableWithCreateNumber("0e1D", true);
930 compareIsCreatableWithCreateNumber(".D", false);
931 compareIsCreatableWithCreateNumber(".e10", false);
932 compareIsCreatableWithCreateNumber(".e10D", false);
933 compareIsCreatableWithCreateNumber("1E2147483647", true);
934 compareIsCreatableWithCreateNumber("1E+2147483647", true);
935 compareIsCreatableWithCreateNumber("1E-2147483647", true);
936 compareIsCreatableWithCreateNumber("1E-2147483648", false);
937 compareIsCreatableWithCreateNumber("1E2147483648", SystemUtils.isJavaVersionAtLeast(JavaVersion.JAVA_21));
938 compareIsCreatableWithCreateNumber("1E+2147483648", SystemUtils.isJavaVersionAtLeast(JavaVersion.JAVA_21));
939 compareIsCreatableWithCreateNumber("1E+2147483649", false);
940 compareIsCreatableWithCreateNumber("1E-2147483649", false);
941 compareIsCreatableWithCreateNumber("1E2147483648D", SystemUtils.isJavaVersionAtLeast(JavaVersion.JAVA_21));
942 compareIsCreatableWithCreateNumber("1E-2147483648D", false);
943 compareIsCreatableWithCreateNumber("1E2147483648F", SystemUtils.isJavaVersionAtLeast(JavaVersion.JAVA_21));
944 compareIsCreatableWithCreateNumber("1E+2147483648F", SystemUtils.isJavaVersionAtLeast(JavaVersion.JAVA_21));
945 compareIsCreatableWithCreateNumber("1E-2147483648F", false);
946 compareIsCreatableWithCreateNumber("1.0E2147483648", SystemUtils.isJavaVersionAtLeast(JavaVersion.JAVA_21));
947 compareIsCreatableWithCreateNumber("1.0E-2147483648", false);
948 compareIsCreatableWithCreateNumber("1E+999999999999999999999", false);
949 compareIsCreatableWithCreateNumber("1E-999999999999999999999", false);
950 compareIsCreatableWithCreateNumber("0.100000001490116121", true);
951 }
952
953 @Test
954 void testIsDigits() {
955 assertFalse(NumberUtils.isDigits(null), "isDigits(null) failed");
956 assertFalse(NumberUtils.isDigits(""), "isDigits('') failed");
957 assertTrue(NumberUtils.isDigits("12345"), "isDigits(String) failed");
958 assertFalse(NumberUtils.isDigits("1234.5"), "isDigits(String) neg 1 failed");
959 assertFalse(NumberUtils.isDigits("1ab"), "isDigits(String) neg 3 failed");
960 assertFalse(NumberUtils.isDigits("abc"), "isDigits(String) neg 4 failed");
961 }
962
963
964
965
966 @Test
967 void testIsNumber() {
968 compareIsNumberWithCreateNumber("12345", true);
969 compareIsNumberWithCreateNumber("1234.5", true);
970 compareIsNumberWithCreateNumber(".12345", true);
971 compareIsNumberWithCreateNumber("1234E5", true);
972 compareIsNumberWithCreateNumber("1234E+5", true);
973 compareIsNumberWithCreateNumber("1234E-5", true);
974 compareIsNumberWithCreateNumber("123.4E5", true);
975 compareIsNumberWithCreateNumber("-1234", true);
976 compareIsNumberWithCreateNumber("-1234.5", true);
977 compareIsNumberWithCreateNumber("-.12345", true);
978 compareIsNumberWithCreateNumber("-0001.12345", true);
979 compareIsNumberWithCreateNumber("-000.12345", true);
980 compareIsNumberWithCreateNumber("+00.12345", true);
981 compareIsNumberWithCreateNumber("+0002.12345", true);
982 compareIsNumberWithCreateNumber("-1234E5", true);
983 compareIsNumberWithCreateNumber("0", true);
984 compareIsNumberWithCreateNumber("-0", true);
985 compareIsNumberWithCreateNumber("01234", true);
986 compareIsNumberWithCreateNumber("-01234", true);
987 compareIsNumberWithCreateNumber("-0xABC123", true);
988 compareIsNumberWithCreateNumber("-0x0", true);
989 compareIsNumberWithCreateNumber("123.4E21D", true);
990 compareIsNumberWithCreateNumber("-221.23F", true);
991 compareIsNumberWithCreateNumber("22338L", true);
992 compareIsNumberWithCreateNumber(null, false);
993 compareIsNumberWithCreateNumber("", false);
994 compareIsNumberWithCreateNumber(" ", false);
995 compareIsNumberWithCreateNumber("\r\n\t", false);
996 compareIsNumberWithCreateNumber("--2.3", false);
997 compareIsNumberWithCreateNumber(".12.3", false);
998 compareIsNumberWithCreateNumber("-123E", false);
999 compareIsNumberWithCreateNumber("-123E+-212", false);
1000 compareIsNumberWithCreateNumber("-123E2.12", false);
1001 compareIsNumberWithCreateNumber("0xGF", false);
1002 compareIsNumberWithCreateNumber("0xFAE-1", false);
1003 compareIsNumberWithCreateNumber(".", false);
1004 compareIsNumberWithCreateNumber("-0ABC123", false);
1005 compareIsNumberWithCreateNumber("123.4E-D", false);
1006 compareIsNumberWithCreateNumber("123.4ED", false);
1007 compareIsNumberWithCreateNumber("+000E.12345", false);
1008 compareIsNumberWithCreateNumber("-000E.12345", false);
1009 compareIsNumberWithCreateNumber("1234E5l", false);
1010 compareIsNumberWithCreateNumber("11a", false);
1011 compareIsNumberWithCreateNumber("1a", false);
1012 compareIsNumberWithCreateNumber("a", false);
1013 compareIsNumberWithCreateNumber("11g", false);
1014 compareIsNumberWithCreateNumber("11z", false);
1015 compareIsNumberWithCreateNumber("11def", false);
1016 compareIsNumberWithCreateNumber("11d11", false);
1017 compareIsNumberWithCreateNumber("11 11", false);
1018 compareIsNumberWithCreateNumber(" 1111", false);
1019 compareIsNumberWithCreateNumber("1111 ", false);
1020 compareIsNumberWithCreateNumber("2.", true);
1021 compareIsNumberWithCreateNumber("1.1L", false);
1022 compareIsNumberWithCreateNumber("+0xF", true);
1023 compareIsNumberWithCreateNumber("+0xFFFFFFFF", true);
1024 compareIsNumberWithCreateNumber("+0xFFFFFFFFFFFFFFFF", true);
1025 compareIsNumberWithCreateNumber(".0", true);
1026 compareIsNumberWithCreateNumber("0.", true);
1027 compareIsNumberWithCreateNumber("0.D", true);
1028 compareIsNumberWithCreateNumber("0e1", true);
1029 compareIsNumberWithCreateNumber("0e1D", true);
1030 compareIsNumberWithCreateNumber(".D", false);
1031 compareIsNumberWithCreateNumber(".e10", false);
1032 compareIsNumberWithCreateNumber(".e10D", false);
1033 }
1034
1035 @Test
1036 void testIsNumberLANG1252() {
1037 compareIsNumberWithCreateNumber("+2", true);
1038 compareIsNumberWithCreateNumber("+2.0", true);
1039 }
1040
1041 @Test
1042 void testIsNumberLANG1385() {
1043 compareIsNumberWithCreateNumber("L", false);
1044 }
1045
1046 @Test
1047 void testIsNumberLANG971() {
1048 compareIsNumberWithCreateNumber("0085", false);
1049 compareIsNumberWithCreateNumber("085", false);
1050 compareIsNumberWithCreateNumber("08", false);
1051 compareIsNumberWithCreateNumber("07", true);
1052 compareIsNumberWithCreateNumber("00", true);
1053 }
1054
1055 @Test
1056 void testIsNumberLANG972() {
1057 compareIsNumberWithCreateNumber("0xABCD", true);
1058 compareIsNumberWithCreateNumber("0XABCD", true);
1059 }
1060
1061 @Test
1062 void testIsNumberLANG992() {
1063 compareIsNumberWithCreateNumber("0.0", true);
1064 compareIsNumberWithCreateNumber("0.4790", true);
1065 }
1066
1067 @ParameterizedTest
1068
1069 @ValueSource(strings = {
1070
1071 "3.14",
1072 "3.14d",
1073 "3.14D",
1074 ".5",
1075 ".5d",
1076 "5.",
1077 "5.d",
1078 "5d",
1079 "0.0",
1080 "0.0d",
1081
1082 "1.23e10",
1083 "1.23e10d",
1084 "1.23E10",
1085 "1.23e-10",
1086 "1.23e-10d",
1087 "1e5",
1088 "1e5d",
1089 ".5e3",
1090 ".5e3d",
1091
1092 "0x1.8p3",
1093 "0x1.8p3d",
1094 "0x.8p0",
1095 "0x1p-3",
1096 "0x1.fffffffffffffp1023",
1097 "0x1.fffffffffffffp1023d",
1098
1099 "01.5",
1100 "01.5d" })
1101
1102 void testIsParsableDoubleTrue(final String input) {
1103 Double.parseDouble(input);
1104 assertTrue(NumberUtils.isParsable(input));
1105 }
1106
1107 @ParameterizedTest
1108 @ValueSource(strings = { "", "0xC1AB", "65CBA2", "pendro", "64, 2", "64.2.2", "64..", "64L", "-", "--2",
1109
1110 "e5", "1e", "1e+", "1e-", "1ee5", "1e5e5",
1111
1112 "f", "d", "-f", "-d", })
1113 void testIsParsableFalse(final String input) {
1114 assertFalse(NumberUtils.isParsable(input));
1115 }
1116
1117 @ParameterizedTest
1118
1119 @ValueSource(strings = {
1120
1121 "3.14f",
1122 "3.14F",
1123 ".5f",
1124 "5.f",
1125 "5f",
1126 "0.0f",
1127
1128 "1.23e10f",
1129 "1.23E10f",
1130 "1.23e-10f",
1131 "1e5f",
1132 ".5e3f",
1133
1134 "0x1.8p3f",
1135 "0x.8p0f",
1136 "0x1p-3f",
1137 "0x1.fffffep127f",
1138
1139 "01.5f"})
1140
1141 void testIsParsableFloatTrue(final String input) {
1142 Float.parseFloat(input);
1143 assertTrue(NumberUtils.isParsable(input));
1144 }
1145
1146
1147
1148
1149
1150
1151
1152 @Test
1153 void testIsParsableFullWidthUnicodeJDK8326627() {
1154
1155 final String fullWidth123 = "\uFF10\uFF11\uFF12";
1156 assertThrows(NumberFormatException.class, () -> Double.parseDouble(fullWidth123));
1157 assertThrows(NumberFormatException.class, () -> Float.parseFloat(fullWidth123));
1158 assertTrue(NumberUtils.isParsable(fullWidth123));
1159 assertFalse(NumberUtils.isParsable(fullWidth123 + ".0"));
1160 assertFalse(NumberUtils.isParsable("0." + fullWidth123));
1161 }
1162
1163 @Test
1164 void testIsParsableInfinity() {
1165
1166 final String s = "Infinity";
1167 assertEquals(Double.POSITIVE_INFINITY, Double.parseDouble(s));
1168 assertEquals(Float.POSITIVE_INFINITY, Float.parseFloat(s));
1169
1170 assertTrue(NumberUtils.isParsable(s));
1171 }
1172
1173 @Test
1174 void testIsParsableInfinityNegative() {
1175
1176 final String s = "-Infinity";
1177 assertEquals(Double.NEGATIVE_INFINITY, Double.parseDouble(s));
1178 assertEquals(Float.NEGATIVE_INFINITY, Float.parseFloat(s));
1179
1180 assertTrue(NumberUtils.isParsable(s));
1181 }
1182
1183 @Test
1184 void testIsParsableInfinityPositive() {
1185
1186 final String s = "+Infinity";
1187 assertEquals(Double.POSITIVE_INFINITY, Double.parseDouble(s));
1188 assertEquals(Float.POSITIVE_INFINITY, Float.parseFloat(s));
1189
1190 assertTrue(NumberUtils.isParsable(s));
1191 }
1192
1193 @Test
1194 void testIsParsableNaN() {
1195
1196 final String s = "NaN";
1197 assertEquals(Double.NaN, Double.parseDouble(s));
1198 assertEquals(Float.NaN, Float.parseFloat(s));
1199
1200 assertTrue(NumberUtils.isParsable(s));
1201 }
1202
1203 @Test
1204 void testIsParsableNull() {
1205
1206 assertFalse(NumberUtils.isParsable(null));
1207 }
1208
1209 @ParameterizedTest
1210
1211 @ValueSource(strings = {
1212 "NaN",
1213 "Infinity",
1214 "-Infinity",
1215 "+Infinity",
1216 "64.",
1217 "-64.",
1218 "64.2",
1219 "64",
1220 "018",
1221 ".18",
1222 "-65",
1223 "-018",
1224 "-018.2",
1225 "-.236",
1226 "2.",
1227 "2.f",
1228 "2.d",
1229 "1.2e-5f",
1230 "1.2e-5d",
1231
1232 "1e5", "1E5", "1.2e5", "1.2E5", "1.2e+5", "1.2e-5", "-1.2e-5", "1e5f", "1e5F", "1e5d", "1e5D",
1233
1234 "2f", "2F", "2d", "2D", "2.0f", "2.0F", "2.0d", "2.0D", "-2.0f", "-2.0d" })
1235
1236 void testIsParsableTrue(final String input) {
1237 assertTrue(NumberUtils.isParsable(input));
1238 }
1239
1240 @Test
1241 void testLang1087() {
1242
1243 assertEquals(Float.class, NumberUtils.createNumber("0.0").getClass());
1244 assertEquals(Float.valueOf("0.0"), NumberUtils.createNumber("0.0"));
1245
1246 assertEquals(Float.class, NumberUtils.createNumber("+0.0").getClass());
1247 assertEquals(Float.valueOf("+0.0"), NumberUtils.createNumber("+0.0"));
1248
1249 assertEquals(Float.class, NumberUtils.createNumber("-0.0").getClass());
1250 assertEquals(Float.valueOf("-0.0"), NumberUtils.createNumber("-0.0"));
1251 }
1252
1253 @Test
1254 void testLANG1252() {
1255 compareIsCreatableWithCreateNumber("+2", true);
1256 compareIsCreatableWithCreateNumber("+2.0", true);
1257 }
1258
1259 @Test
1260 void testLang1729IsParsableByte() {
1261 assertTrue(isParsableByte("1"));
1262 assertFalse(isParsableByte("1 2 3"));
1263 assertTrue(isParsableByte("ï¼ï¼ï¼"));
1264 assertFalse(isParsableByte("ï¼ ï¼ ï¼"));
1265 }
1266
1267 @Test
1268 void testLang1729IsParsableDouble() {
1269 assertTrue(isParsableDouble("1"));
1270 assertTrue(isParsableDouble("1."));
1271 assertTrue(isParsableDouble("1.f"));
1272 assertTrue(isParsableDouble("1.d"));
1273 assertTrue(isParsableDouble("1.0"));
1274 assertFalse(isParsableDouble("1.0."));
1275 assertFalse(isParsableDouble("1 2 3"));
1276 assertFalse(isParsableDouble("ï¼ ï¼ ï¼"));
1277 }
1278
1279 @Test
1280 void testLang1729IsParsableFloat() {
1281 assertTrue(isParsableFloat("1"));
1282 assertTrue(isParsableFloat("1."));
1283 assertTrue(isParsableFloat("1.f"));
1284 assertTrue(isParsableFloat("1.d"));
1285 assertTrue(isParsableFloat("1.0"));
1286 assertFalse(isParsableFloat("1.0."));
1287 assertFalse(isParsableFloat("1 2 3"));
1288 assertFalse(isParsableFloat("ï¼ ï¼ ï¼"));
1289 }
1290
1291 @Test
1292 void testLang1729IsParsableInteger() {
1293 assertTrue(isParsableInteger("1"));
1294 assertFalse(isParsableInteger("1 2 3"));
1295 assertTrue(isParsableInteger("ï¼ï¼ï¼"));
1296 assertFalse(isParsableInteger("ï¼ ï¼ ï¼"));
1297 }
1298
1299 @Test
1300 void testLang1729IsParsableLong() {
1301 assertTrue(isParsableLong("1"));
1302 assertFalse(isParsableLong("1 2 3"));
1303 assertTrue(isParsableLong("ï¼ï¼ï¼"));
1304 assertFalse(isParsableLong("ï¼ ï¼ ï¼"));
1305 }
1306
1307 @Test
1308 void testLang1729IsParsableShort() {
1309 assertTrue(isParsableShort("1"));
1310 assertFalse(isParsableShort("1 2 3"));
1311 assertTrue(isParsableShort("ï¼ï¼ï¼"));
1312 assertFalse(isParsableShort("ï¼ ï¼ ï¼"));
1313 }
1314
1315
1316
1317
1318 @Test
1319 void testLang1821() {
1320 compareIsCreatableWithCreateNumber("123L", true);
1321 compareIsCreatableWithCreateNumber("0xdef", true);
1322 compareIsCreatableWithCreateNumber("0xdefL", true);
1323 compareIsCreatableWithCreateNumber("0XDEFl", true);
1324
1325 compareIsCreatableWithCreateNumber("0x" + Integer.toHexString(Integer.MAX_VALUE), true);
1326 compareIsCreatableWithCreateNumber("0x" + Integer.toHexString(Integer.MAX_VALUE) + "l", true);
1327 compareIsCreatableWithCreateNumber("0x" + Integer.toHexString(Integer.MAX_VALUE) + "L", true);
1328 compareIsCreatableWithCreateNumber("0X" + Integer.toHexString(Integer.MAX_VALUE), true);
1329 compareIsCreatableWithCreateNumber("0X" + Integer.toHexString(Integer.MAX_VALUE) + "l", true);
1330 compareIsCreatableWithCreateNumber("0X" + Integer.toHexString(Integer.MAX_VALUE) + "L", true);
1331
1332 compareIsCreatableWithCreateNumber("0x" + Long.toHexString(Long.MAX_VALUE), true);
1333 compareIsCreatableWithCreateNumber("0x" + Long.toHexString(Long.MAX_VALUE) + "l", true);
1334 compareIsCreatableWithCreateNumber("0x" + Long.toHexString(Long.MAX_VALUE) + "L", true);
1335 compareIsCreatableWithCreateNumber("0X" + Long.toHexString(Long.MAX_VALUE), true);
1336 compareIsCreatableWithCreateNumber("0X" + Long.toHexString(Long.MAX_VALUE) + "l", true);
1337 compareIsCreatableWithCreateNumber("0X" + Long.toHexString(Long.MAX_VALUE) + "L", true);
1338 }
1339
1340 @Test
1341 void testLang300() {
1342 NumberUtils.createNumber("-1l");
1343 NumberUtils.createNumber("01l");
1344 NumberUtils.createNumber("1l");
1345 }
1346
1347 @Test
1348 void testLang381() {
1349 assertTrue(Double.isNaN(NumberUtils.min(1.2, 2.5, Double.NaN)));
1350 assertTrue(Double.isNaN(NumberUtils.max(1.2, 2.5, Double.NaN)));
1351 assertTrue(Float.isNaN(NumberUtils.min(1.2f, 2.5f, Float.NaN)));
1352 assertTrue(Float.isNaN(NumberUtils.max(1.2f, 2.5f, Float.NaN)));
1353 final double[] a = { 1.2, Double.NaN, 3.7, 27.0, 42.0, Double.NaN };
1354 assertTrue(Double.isNaN(NumberUtils.max(a)));
1355 assertTrue(Double.isNaN(NumberUtils.min(a)));
1356 final double[] b = { Double.NaN, 1.2, Double.NaN, 3.7, 27.0, 42.0, Double.NaN };
1357 assertTrue(Double.isNaN(NumberUtils.max(b)));
1358 assertTrue(Double.isNaN(NumberUtils.min(b)));
1359 final float[] aF = { 1.2f, Float.NaN, 3.7f, 27.0f, 42.0f, Float.NaN };
1360 assertTrue(Float.isNaN(NumberUtils.max(aF)));
1361 final float[] bF = { Float.NaN, 1.2f, Float.NaN, 3.7f, 27.0f, 42.0f, Float.NaN };
1362 assertTrue(Float.isNaN(NumberUtils.max(bF)));
1363 }
1364
1365 @Test
1366 void testLang747() {
1367 assertEquals(Integer.valueOf(0x8000), NumberUtils.createNumber("0x8000"));
1368 assertEquals(Integer.valueOf(0x80000), NumberUtils.createNumber("0x80000"));
1369 assertEquals(Integer.valueOf(0x800000), NumberUtils.createNumber("0x800000"));
1370 assertEquals(Integer.valueOf(0x8000000), NumberUtils.createNumber("0x8000000"));
1371 assertEquals(Integer.valueOf(0x7FFFFFFF), NumberUtils.createNumber("0x7FFFFFFF"));
1372 assertEquals(Long.valueOf(0x80000000L), NumberUtils.createNumber("0x80000000"));
1373 assertEquals(Long.valueOf(0xFFFFFFFFL), NumberUtils.createNumber("0xFFFFFFFF"));
1374
1375 assertEquals(Integer.valueOf(0x8000000), NumberUtils.createNumber("0x08000000"));
1376 assertEquals(Integer.valueOf(0x7FFFFFFF), NumberUtils.createNumber("0x007FFFFFFF"));
1377 assertEquals(Long.valueOf(0x80000000L), NumberUtils.createNumber("0x080000000"));
1378 assertEquals(Long.valueOf(0xFFFFFFFFL), NumberUtils.createNumber("0x00FFFFFFFF"));
1379 assertEquals(Long.valueOf(0x800000000L), NumberUtils.createNumber("0x800000000"));
1380 assertEquals(Long.valueOf(0x8000000000L), NumberUtils.createNumber("0x8000000000"));
1381 assertEquals(Long.valueOf(0x80000000000L), NumberUtils.createNumber("0x80000000000"));
1382 assertEquals(Long.valueOf(0x800000000000L), NumberUtils.createNumber("0x800000000000"));
1383 assertEquals(Long.valueOf(0x8000000000000L), NumberUtils.createNumber("0x8000000000000"));
1384 assertEquals(Long.valueOf(0x80000000000000L), NumberUtils.createNumber("0x80000000000000"));
1385 assertEquals(Long.valueOf(0x800000000000000L), NumberUtils.createNumber("0x800000000000000"));
1386 assertEquals(Long.valueOf(0x7FFFFFFFFFFFFFFFL), NumberUtils.createNumber("0x7FFFFFFFFFFFFFFF"));
1387
1388 assertEquals(new BigInteger("8000000000000000", 16), NumberUtils.createNumber("0x8000000000000000"));
1389 assertEquals(new BigInteger("FFFFFFFFFFFFFFFF", 16), NumberUtils.createNumber("0xFFFFFFFFFFFFFFFF"));
1390
1391 assertEquals(Long.valueOf(0x80000000000000L), NumberUtils.createNumber("0x00080000000000000"));
1392 assertEquals(Long.valueOf(0x800000000000000L), NumberUtils.createNumber("0x0800000000000000"));
1393 assertEquals(Long.valueOf(0x7FFFFFFFFFFFFFFFL), NumberUtils.createNumber("0x07FFFFFFFFFFFFFFF"));
1394
1395 assertEquals(new BigInteger("8000000000000000", 16), NumberUtils.createNumber("0x00008000000000000000"));
1396 assertEquals(new BigInteger("FFFFFFFFFFFFFFFF", 16), NumberUtils.createNumber("0x0FFFFFFFFFFFFFFFF"));
1397 }
1398
1399 @Test
1400 void testLANG971() {
1401 compareIsCreatableWithCreateNumber("0085", false);
1402 compareIsCreatableWithCreateNumber("085", false);
1403 compareIsCreatableWithCreateNumber("08", false);
1404 compareIsCreatableWithCreateNumber("07", true);
1405 compareIsCreatableWithCreateNumber("00", true);
1406 }
1407
1408 @Test
1409 void testLANG972() {
1410 compareIsCreatableWithCreateNumber("0xABCD", true);
1411 compareIsCreatableWithCreateNumber("0XABCD", true);
1412 }
1413
1414 @Test
1415 void testLANG992() {
1416 compareIsCreatableWithCreateNumber("0.0", true);
1417 compareIsCreatableWithCreateNumber("0.4790", true);
1418 }
1419
1420 @Test
1421 void testMaxByte() {
1422 assertEquals((byte) 5, NumberUtils.max((byte) 5), "max(byte[]) failed for array length 1");
1423 assertEquals((byte) 9, NumberUtils.max((byte) 6, (byte) 9), "max(byte[]) failed for array length 2");
1424 assertEquals((byte) 10, NumberUtils.max((byte) -10, (byte) -5, (byte) 0, (byte) 5, (byte) 10), "max(byte[]) failed for array length 5");
1425 assertEquals((byte) 10, NumberUtils.max((byte) -10, (byte) -5, (byte) 0, (byte) 5, (byte) 10));
1426 assertEquals((byte) 10, NumberUtils.max((byte) -5, (byte) 0, (byte) 10, (byte) 5, (byte) -10));
1427 }
1428
1429 @Test
1430 void testMaxByte_emptyArray() {
1431 assertIllegalArgumentException(NumberUtils::max);
1432 }
1433
1434 @Test
1435 void testMaxByte_nullArray() {
1436 assertNullPointerException(() -> NumberUtils.max((byte[]) null));
1437 }
1438
1439 @Test
1440 void testMaxDouble() {
1441 assertEquals(5.1d, NumberUtils.max(5.1d), "max(double[]) failed for array length 1");
1442 assertEquals(9.2d, NumberUtils.max(6.3d, 9.2d), "max(double[]) failed for array length 2");
1443 assertEquals(10.4d, NumberUtils.max(-10.5d, -5.6d, 0, 5.7d, 10.4d), "max(double[]) failed for double length 5");
1444 assertEquals(10d, NumberUtils.max(-10d, -5d, 0d, 5d, 10d));
1445 assertEquals(10d, NumberUtils.max(-5d, 0d, 10d, 5d, -10d));
1446 }
1447
1448 @Test
1449 void testMaxDouble_emptyArray() {
1450 assertIllegalArgumentException(NumberUtils::max);
1451 }
1452
1453 @Test
1454 void testMaxDouble_nullArray() {
1455 assertNullPointerException(() -> NumberUtils.max((double[]) null));
1456 }
1457
1458 @Test
1459 void testMaxFloat() {
1460 assertEquals(5.1f, NumberUtils.max(5.1f), "max(float[]) failed for array length 1");
1461 assertEquals(9.2f, NumberUtils.max(6.3f, 9.2f), "max(float[]) failed for array length 2");
1462 assertEquals(10.4f, NumberUtils.max(-10.5f, -5.6f, 0, 5.7f, 10.4f), "max(float[]) failed for float length 5");
1463 assertEquals(10f, NumberUtils.max(-10f, -5f, 0f, 5f, 10f), 0.0001f);
1464 assertEquals(10f, NumberUtils.max(-5f, 0f, 10f, 5f, -10f), 0.0001f);
1465 }
1466
1467 @Test
1468 void testMaxFloat_emptyArray() {
1469 assertIllegalArgumentException(NumberUtils::max);
1470 }
1471
1472 @Test
1473 void testMaxFloat_nullArray() {
1474 assertNullPointerException(() -> NumberUtils.max((float[]) null));
1475 }
1476
1477 @Test
1478 void testMaximumByte() {
1479 final byte low = 123;
1480 final byte mid = 123 + 1;
1481 final byte high = 123 + 2;
1482 assertEquals(high, NumberUtils.max(low, mid, high), "maximum(byte, byte, byte) 1 failed");
1483 assertEquals(high, NumberUtils.max(mid, low, high), "maximum(byte, byte, byte) 2 failed");
1484 assertEquals(high, NumberUtils.max(mid, high, low), "maximum(byte, byte, byte) 3 failed");
1485 assertEquals(high, NumberUtils.max(high, mid, high), "maximum(byte, byte, byte) 4 failed");
1486 }
1487
1488 @Test
1489 void testMaximumDouble() {
1490 final double low = 12.3;
1491 final double mid = 12.3 + 1;
1492 final double high = 12.3 + 2;
1493 assertEquals(high, NumberUtils.max(low, mid, high), 0.0001);
1494 assertEquals(high, NumberUtils.max(mid, low, high), 0.0001);
1495 assertEquals(high, NumberUtils.max(mid, high, low), 0.0001);
1496 assertEquals(mid, NumberUtils.max(low, mid, low), 0.0001);
1497 assertEquals(high, NumberUtils.max(high, mid, high), 0.0001);
1498 }
1499
1500 @Test
1501 void testMaximumFloat() {
1502 final float low = 12.3f;
1503 final float mid = 12.3f + 1;
1504 final float high = 12.3f + 2;
1505 assertEquals(high, NumberUtils.max(low, mid, high), 0.0001f);
1506 assertEquals(high, NumberUtils.max(mid, low, high), 0.0001f);
1507 assertEquals(high, NumberUtils.max(mid, high, low), 0.0001f);
1508 assertEquals(mid, NumberUtils.max(low, mid, low), 0.0001f);
1509 assertEquals(high, NumberUtils.max(high, mid, high), 0.0001f);
1510 }
1511
1512 @Test
1513 void testMaximumInt() {
1514 assertEquals(12345, NumberUtils.max(12345, 12345 - 1, 12345 - 2), "maximum(int, int, int) 1 failed");
1515 assertEquals(12345, NumberUtils.max(12345 - 1, 12345, 12345 - 2), "maximum(int, int, int) 2 failed");
1516 assertEquals(12345, NumberUtils.max(12345 - 1, 12345 - 2, 12345), "maximum(int, int, int) 3 failed");
1517 assertEquals(12345, NumberUtils.max(12345 - 1, 12345, 12345), "maximum(int, int, int) 4 failed");
1518 assertEquals(12345, NumberUtils.max(12345, 12345, 12345), "maximum(int, int, int) 5 failed");
1519 }
1520
1521 @Test
1522 void testMaximumLong() {
1523 assertEquals(12345L, NumberUtils.max(12345L, 12345L - 1L, 12345L - 2L), "maximum(long, long, long) 1 failed");
1524 assertEquals(12345L, NumberUtils.max(12345L - 1L, 12345L, 12345L - 2L), "maximum(long, long, long) 2 failed");
1525 assertEquals(12345L, NumberUtils.max(12345L - 1L, 12345L - 2L, 12345L), "maximum(long, long, long) 3 failed");
1526 assertEquals(12345L, NumberUtils.max(12345L - 1L, 12345L, 12345L), "maximum(long, long, long) 4 failed");
1527 assertEquals(12345L, NumberUtils.max(12345L, 12345L, 12345L), "maximum(long, long, long) 5 failed");
1528 }
1529
1530 @Test
1531 void testMaximumShort() {
1532 final short low = 1234;
1533 final short mid = 1234 + 1;
1534 final short high = 1234 + 2;
1535 assertEquals(high, NumberUtils.max(low, mid, high), "maximum(short, short, short) 1 failed");
1536 assertEquals(high, NumberUtils.max(mid, low, high), "maximum(short, short, short) 2 failed");
1537 assertEquals(high, NumberUtils.max(mid, high, low), "maximum(short, short, short) 3 failed");
1538 assertEquals(high, NumberUtils.max(high, mid, high), "maximum(short, short, short) 4 failed");
1539 }
1540
1541 @Test
1542 void testMaxInt() {
1543 assertEquals(5, NumberUtils.max(5), "max(int[]) failed for array length 1");
1544 assertEquals(9, NumberUtils.max(6, 9), "max(int[]) failed for array length 2");
1545 assertEquals(10, NumberUtils.max(-10, -5, 0, 5, 10), "max(int[]) failed for array length 5");
1546 assertEquals(10, NumberUtils.max(-10, -5, 0, 5, 10));
1547 assertEquals(10, NumberUtils.max(-5, 0, 10, 5, -10));
1548 }
1549
1550 @Test
1551 void testMaxInt_emptyArray() {
1552 assertIllegalArgumentException(NumberUtils::max);
1553 }
1554
1555 @Test
1556 void testMaxInt_nullArray() {
1557 assertNullPointerException(() -> NumberUtils.max((int[]) null));
1558 }
1559
1560 @Test
1561 void testMaxLong() {
1562 assertEquals(5L, NumberUtils.max(5L), "max(long[]) failed for array length 1");
1563 assertEquals(9L, NumberUtils.max(6L, 9L), "max(long[]) failed for array length 2");
1564 assertEquals(10L, NumberUtils.max(-10L, -5L, 0L, 5L, 10L), "max(long[]) failed for array length 5");
1565 assertEquals(10L, NumberUtils.max(-10L, -5L, 0L, 5L, 10L));
1566 assertEquals(10L, NumberUtils.max(-5L, 0L, 10L, 5L, -10L));
1567 }
1568
1569 @Test
1570 void testMaxLong_emptyArray() {
1571 assertIllegalArgumentException(NumberUtils::max);
1572 }
1573
1574 @Test
1575 void testMaxLong_nullArray() {
1576 assertNullPointerException(() -> NumberUtils.max((long[]) null));
1577 }
1578
1579 @Test
1580 void testMaxShort() {
1581 assertEquals((short) 5, NumberUtils.max((short) 5), "max(short[]) failed for array length 1");
1582 assertEquals((short) 9, NumberUtils.max((short) 6, (short) 9), "max(short[]) failed for array length 2");
1583 assertEquals((short) 10, NumberUtils.max((short) -10, (short) -5, (short) 0, (short) 5, (short) 10), "max(short[]) failed for array length 5");
1584 assertEquals((short) 10, NumberUtils.max((short) -10, (short) -5, (short) 0, (short) 5, (short) 10));
1585 assertEquals((short) 10, NumberUtils.max((short) -5, (short) 0, (short) 10, (short) 5, (short) -10));
1586 }
1587
1588 @Test
1589 void testMaxShort_emptyArray() {
1590 assertIllegalArgumentException(NumberUtils::max);
1591 }
1592
1593 @Test
1594 void testMaxShort_nullArray() {
1595 assertNullPointerException(() -> NumberUtils.max((short[]) null));
1596 }
1597
1598 @Test
1599 void testMinByte() {
1600 assertEquals((byte) 5, NumberUtils.min((byte) 5), "min(byte[]) failed for array length 1");
1601 assertEquals((byte) 6, NumberUtils.min((byte) 6, (byte) 9), "min(byte[]) failed for array length 2");
1602 assertEquals((byte) -10, NumberUtils.min((byte) -10, (byte) -5, (byte) 0, (byte) 5, (byte) 10));
1603 assertEquals((byte) -10, NumberUtils.min((byte) -5, (byte) 0, (byte) -10, (byte) 5, (byte) 10));
1604 }
1605
1606 @Test
1607 void testMinByte_emptyArray() {
1608 assertIllegalArgumentException(NumberUtils::min);
1609 }
1610
1611 @Test
1612 void testMinByte_nullArray() {
1613 assertNullPointerException(() -> NumberUtils.min((byte[]) null));
1614 }
1615
1616 @Test
1617 void testMinDouble() {
1618 assertEquals(5.12, NumberUtils.min(5.12), "min(double[]) failed for array length 1");
1619 assertEquals(6.23, NumberUtils.min(6.23, 9.34), "min(double[]) failed for array length 2");
1620 assertEquals(-10.45, NumberUtils.min(-10.45, -5.56, 0, 5.67, 10.78), "min(double[]) failed for array length 5");
1621 assertEquals(-10, NumberUtils.min(-10, -5, 0, 5, 10), 0.0001);
1622 assertEquals(-10, NumberUtils.min(-5, 0, -10, 5, 10), 0.0001);
1623 assertEquals(5.12, NumberUtils.min(6.11, 5.12));
1624 }
1625
1626 @Test
1627 void testMinDouble_emptyArray() {
1628 assertIllegalArgumentException(NumberUtils::min);
1629 }
1630
1631 @Test
1632 void testMinDouble_nullArray() {
1633 assertNullPointerException(() -> NumberUtils.min((double[]) null));
1634 }
1635
1636 @Test
1637 void testMinFloat() {
1638 assertEquals(5.9f, NumberUtils.min(5.9f), "min(float[]) failed for array length 1");
1639 assertEquals(6.8f, NumberUtils.min(6.8f, 9.7f), "min(float[]) failed for array length 2");
1640 assertEquals(-10.6f, NumberUtils.min(-10.6f, -5.5f, 0, 5.4f, 10.3f), "min(float[]) failed for array length 5");
1641 assertEquals(-10, NumberUtils.min(-10, -5, 0, 5, 10), 0.0001f);
1642 assertEquals(-10, NumberUtils.min(-5, 0, -10, 5, 10), 0.0001f);
1643 assertEquals(Float.NaN, NumberUtils.min(6.8f, Float.NaN));
1644 assertEquals(3.7f, NumberUtils.min(6.8f, 3.7f));
1645 }
1646
1647 @Test
1648 void testMinFloat_emptyArray() {
1649 assertIllegalArgumentException(NumberUtils::min);
1650 }
1651
1652 @Test
1653 void testMinFloat_nullArray() {
1654 assertNullPointerException(() -> NumberUtils.min((float[]) null));
1655 }
1656
1657 @Test
1658 void testMinimumByte() {
1659 final byte low = 123;
1660 final byte mid = 123 + 1;
1661 final byte high = 123 + 2;
1662 assertEquals(low, NumberUtils.min(low, mid, high), "minimum(byte, byte, byte) 1 failed");
1663 assertEquals(low, NumberUtils.min(mid, low, high), "minimum(byte, byte, byte) 2 failed");
1664 assertEquals(low, NumberUtils.min(mid, high, low), "minimum(byte, byte, byte) 3 failed");
1665 assertEquals(low, NumberUtils.min(low, mid, low), "minimum(byte, byte, byte) 4 failed");
1666 }
1667
1668 @Test
1669 void testMinimumDouble() {
1670 final double low = 12.3;
1671 final double mid = 12.3 + 1;
1672 final double high = 12.3 + 2;
1673 assertEquals(low, NumberUtils.min(low, mid, high), 0.0001);
1674 assertEquals(low, NumberUtils.min(mid, low, high), 0.0001);
1675 assertEquals(low, NumberUtils.min(mid, high, low), 0.0001);
1676 assertEquals(low, NumberUtils.min(low, mid, low), 0.0001);
1677 assertEquals(mid, NumberUtils.min(high, mid, high), 0.0001);
1678 }
1679
1680 @Test
1681 void testMinimumFloat() {
1682 final float low = 12.3f;
1683 final float mid = 12.3f + 1;
1684 final float high = 12.3f + 2;
1685 assertEquals(low, NumberUtils.min(low, mid, high), 0.0001f);
1686 assertEquals(low, NumberUtils.min(mid, low, high), 0.0001f);
1687 assertEquals(low, NumberUtils.min(mid, high, low), 0.0001f);
1688 assertEquals(low, NumberUtils.min(low, mid, low), 0.0001f);
1689 assertEquals(mid, NumberUtils.min(high, mid, high), 0.0001f);
1690 }
1691
1692 @Test
1693 void testMinimumInt() {
1694 assertEquals(12345, NumberUtils.min(12345, 12345 + 1, 12345 + 2), "minimum(int, int, int) 1 failed");
1695 assertEquals(12345, NumberUtils.min(12345 + 1, 12345, 12345 + 2), "minimum(int, int, int) 2 failed");
1696 assertEquals(12345, NumberUtils.min(12345 + 1, 12345 + 2, 12345), "minimum(int, int, int) 3 failed");
1697 assertEquals(12345, NumberUtils.min(12345 + 1, 12345, 12345), "minimum(int, int, int) 4 failed");
1698 assertEquals(12345, NumberUtils.min(12345, 12345, 12345), "minimum(int, int, int) 5 failed");
1699 }
1700
1701 @Test
1702 void testMinimumLong() {
1703 assertEquals(12345L, NumberUtils.min(12345L, 12345L + 1L, 12345L + 2L), "minimum(long, long, long) 1 failed");
1704 assertEquals(12345L, NumberUtils.min(12345L + 1L, 12345L, 12345 + 2L), "minimum(long, long, long) 2 failed");
1705 assertEquals(12345L, NumberUtils.min(12345L + 1L, 12345L + 2L, 12345L), "minimum(long, long, long) 3 failed");
1706 assertEquals(12345L, NumberUtils.min(12345L + 1L, 12345L, 12345L), "minimum(long, long, long) 4 failed");
1707 assertEquals(12345L, NumberUtils.min(12345L, 12345L, 12345L), "minimum(long, long, long) 5 failed");
1708 }
1709
1710 @Test
1711 void testMinimumShort() {
1712 final short low = 1234;
1713 final short mid = 1234 + 1;
1714 final short high = 1234 + 2;
1715 assertEquals(low, NumberUtils.min(low, mid, high), "minimum(short, short, short) 1 failed");
1716 assertEquals(low, NumberUtils.min(mid, low, high), "minimum(short, short, short) 2 failed");
1717 assertEquals(low, NumberUtils.min(mid, high, low), "minimum(short, short, short) 3 failed");
1718 assertEquals(low, NumberUtils.min(low, mid, low), "minimum(short, short, short) 4 failed");
1719 }
1720
1721 @Test
1722 void testMinInt() {
1723 assertEquals(5, NumberUtils.min(5), "min(int[]) failed for array length 1");
1724 assertEquals(6, NumberUtils.min(6, 9), "min(int[]) failed for array length 2");
1725 assertEquals(-10, NumberUtils.min(-10, -5, 0, 5, 10));
1726 assertEquals(-10, NumberUtils.min(-5, 0, -10, 5, 10));
1727 }
1728
1729 @Test
1730 void testMinInt_emptyArray() {
1731 assertIllegalArgumentException(NumberUtils::min);
1732 }
1733
1734 @Test
1735 void testMinInt_nullArray() {
1736 assertNullPointerException(() -> NumberUtils.min((int[]) null));
1737 }
1738
1739 @Test
1740 void testMinLong() {
1741 assertEquals(5L, NumberUtils.min(5L), "min(long[]) failed for array length 1");
1742 assertEquals(6L, NumberUtils.min(6L, 9L), "min(long[]) failed for array length 2");
1743 assertEquals(-10L, NumberUtils.min(-10L, -5L, 0L, 5L, 10L));
1744 assertEquals(-10L, NumberUtils.min(-5L, 0L, -10L, 5L, 10L));
1745 }
1746
1747 @Test
1748 void testMinLong_emptyArray() {
1749 assertIllegalArgumentException(NumberUtils::min);
1750 }
1751
1752 @Test
1753 void testMinLong_nullArray() {
1754 assertNullPointerException(() -> NumberUtils.min((long[]) null));
1755 }
1756
1757 @Test
1758 void testMinMaxSignedZero() {
1759
1760
1761
1762 assertEquals(Double.doubleToRawLongBits(0.0d), Double.doubleToRawLongBits(NumberUtils.max(-0.0d, 0.0d)));
1763 assertEquals(Double.doubleToRawLongBits(0.0d), Double.doubleToRawLongBits(NumberUtils.max(0.0d, -0.0d)));
1764 assertEquals(Double.doubleToRawLongBits(-0.0d), Double.doubleToRawLongBits(NumberUtils.min(-0.0d, 0.0d)));
1765 assertEquals(Double.doubleToRawLongBits(-0.0d), Double.doubleToRawLongBits(NumberUtils.min(0.0d, -0.0d)));
1766 assertEquals(Float.floatToRawIntBits(0.0f), Float.floatToRawIntBits(NumberUtils.max(-0.0f, 0.0f)));
1767 assertEquals(Float.floatToRawIntBits(0.0f), Float.floatToRawIntBits(NumberUtils.max(0.0f, -0.0f)));
1768 assertEquals(Float.floatToRawIntBits(-0.0f), Float.floatToRawIntBits(NumberUtils.min(-0.0f, 0.0f)));
1769 assertEquals(Float.floatToRawIntBits(-0.0f), Float.floatToRawIntBits(NumberUtils.min(0.0f, -0.0f)));
1770
1771 assertEquals(Double.doubleToRawLongBits(NumberUtils.max(-0.0d, 0.0d, 0.0d)), Double.doubleToRawLongBits(NumberUtils.max(-0.0d, 0.0d)));
1772 assertEquals(Double.doubleToRawLongBits(NumberUtils.min(0.0d, -0.0d, 0.0d)), Double.doubleToRawLongBits(NumberUtils.min(0.0d, -0.0d)));
1773 }
1774
1775 @Test
1776 void testMinShort() {
1777 assertEquals((short) 5, NumberUtils.min((short) 5), "min(short[]) failed for array length 1");
1778 assertEquals((short) 6, NumberUtils.min((short) 6, (short) 9), "min(short[]) failed for array length 2");
1779 assertEquals((short) -10, NumberUtils.min((short) -10, (short) -5, (short) 0, (short) 5, (short) 10));
1780 assertEquals((short) -10, NumberUtils.min((short) -5, (short) 0, (short) -10, (short) 5, (short) 10));
1781 }
1782
1783 @Test
1784 void testMinShort_emptyArray() {
1785 assertIllegalArgumentException(NumberUtils::min);
1786 }
1787
1788 @Test
1789 void testMinShort_nullArray() {
1790 assertNullPointerException(() -> NumberUtils.min((short[]) null));
1791 }
1792
1793
1794
1795
1796 @Test
1797 void testStringCreateNumberEnsureNoPrecisionLoss() {
1798 assertInstanceOf(Float.class, NumberUtils.createNumber("1.23"));
1799 assertInstanceOf(Double.class, NumberUtils.createNumber("3.40282354e+38"));
1800 assertInstanceOf(BigDecimal.class, NumberUtils.createNumber("1.797693134862315759e+308"));
1801
1802 assertInstanceOf(Float.class, NumberUtils.createNumber("001.12"));
1803 assertInstanceOf(Float.class, NumberUtils.createNumber("-001.12"));
1804 assertInstanceOf(Float.class, NumberUtils.createNumber("+001.12"));
1805 assertInstanceOf(Double.class, NumberUtils.createNumber("003.40282354e+38"));
1806 assertInstanceOf(Double.class, NumberUtils.createNumber("-003.40282354e+38"));
1807 assertInstanceOf(Double.class, NumberUtils.createNumber("+003.40282354e+38"));
1808 assertInstanceOf(BigDecimal.class, NumberUtils.createNumber("0001.797693134862315759e+308"));
1809 assertInstanceOf(BigDecimal.class, NumberUtils.createNumber("-001.797693134862315759e+308"));
1810 assertInstanceOf(BigDecimal.class, NumberUtils.createNumber("+001.797693134862315759e+308"));
1811
1812 assertInstanceOf(Double.class, NumberUtils.createNumber("2.2250738585072014E-308"));
1813 assertInstanceOf(Double.class, NumberUtils.createNumber("2.2250738585072014E-308D"));
1814 assertInstanceOf(Double.class, NumberUtils.createNumber("2.2250738585072014E-308F"));
1815 assertInstanceOf(Double.class, NumberUtils.createNumber("4.9E-324"));
1816 assertInstanceOf(Double.class, NumberUtils.createNumber("4.9E-324D"));
1817 assertInstanceOf(Double.class, NumberUtils.createNumber("4.9E-324F"));
1818 assertInstanceOf(Double.class, NumberUtils.createNumber("1.7976931348623157E308"));
1819 assertInstanceOf(Double.class, NumberUtils.createNumber("1.7976931348623157E308D"));
1820 assertInstanceOf(Double.class, NumberUtils.createNumber("1.7976931348623157E308F"));
1821 assertInstanceOf(Double.class, NumberUtils.createNumber("4.9e-324D"));
1822 assertInstanceOf(Double.class, NumberUtils.createNumber("4.9e-324F"));
1823
1824 assertInstanceOf(Float.class, NumberUtils.createNumber("1.1"));
1825 assertInstanceOf(Float.class, NumberUtils.createNumber("1.01"));
1826 assertInstanceOf(Float.class, NumberUtils.createNumber("1.001"));
1827 assertInstanceOf(Float.class, NumberUtils.createNumber("1.0001"));
1828 assertInstanceOf(Float.class, NumberUtils.createNumber("1.00001"));
1829 assertInstanceOf(Float.class, NumberUtils.createNumber("1.000001"));
1830 assertInstanceOf(Float.class, NumberUtils.createNumber("1.0000001"));
1831 assertInstanceOf(Double.class, NumberUtils.createNumber("1.00000001"));
1832 assertInstanceOf(Double.class, NumberUtils.createNumber("1.000000001"));
1833 assertInstanceOf(Double.class, NumberUtils.createNumber("1.0000000001"));
1834 assertInstanceOf(Double.class, NumberUtils.createNumber("1.00000000001"));
1835 assertInstanceOf(Double.class, NumberUtils.createNumber("1.000000000001"));
1836 assertInstanceOf(Double.class, NumberUtils.createNumber("1.0000000000001"));
1837 assertInstanceOf(Double.class, NumberUtils.createNumber("1.00000000000001"));
1838 assertInstanceOf(Double.class, NumberUtils.createNumber("1.000000000000001"));
1839
1840
1841
1842 assertInstanceOf(Float.class, NumberUtils.createNumber("1.0000000000000001"));
1843 assertInstanceOf(Float.class, NumberUtils.createNumber("1.00000000000000001"));
1844 assertInstanceOf(Float.class, NumberUtils.createNumber("1.000000000000000001"));
1845 assertInstanceOf(Float.class, NumberUtils.createNumber("1.0000000000000000001"));
1846 assertInstanceOf(Float.class, NumberUtils.createNumber("1.00000000000000000001"));
1847 assertInstanceOf(Float.class, NumberUtils.createNumber("1.000000000000000000001"));
1848 assertInstanceOf(Float.class, NumberUtils.createNumber("1.0000000000000000000001"));
1849 assertInstanceOf(Float.class, NumberUtils.createNumber("1.00000000000000000000001"));
1850 }
1851
1852
1853
1854
1855 @Test
1856 void testStringToDoubleString() {
1857 assertEquals(NumberUtils.toDouble("-1.2345"), -1.2345d, "toDouble(String) 1 failed");
1858 assertEquals(1.2345d, NumberUtils.toDouble("1.2345"), "toDouble(String) 2 failed");
1859 assertEquals(0.0d, NumberUtils.toDouble("abc"), "toDouble(String) 3 failed");
1860
1861 assertEquals(NumberUtils.toDouble("-001.2345"), -1.2345d, "toDouble(String) 4 failed");
1862 assertEquals(1.2345d, NumberUtils.toDouble("+001.2345"), "toDouble(String) 5 failed");
1863 assertEquals(1.2345d, NumberUtils.toDouble("001.2345"), "toDouble(String) 6 failed");
1864 assertEquals(0d, NumberUtils.toDouble("000.00000"), "toDouble(String) 7 failed");
1865 assertEquals(NumberUtils.toDouble(Double.MAX_VALUE + ""), Double.MAX_VALUE, "toDouble(Double.MAX_VALUE) failed");
1866 assertEquals(NumberUtils.toDouble(Double.MIN_VALUE + ""), Double.MIN_VALUE, "toDouble(Double.MIN_VALUE) failed");
1867 assertEquals(0.0d, NumberUtils.toDouble(""), "toDouble(empty) failed");
1868 assertEquals(0.0d, NumberUtils.toDouble((String) null), "toDouble(null) failed");
1869 }
1870
1871
1872
1873
1874 @Test
1875 void testStringToDoubleStringD() {
1876 assertEquals(1.2345d, NumberUtils.toDouble("1.2345", 5.1d), "toDouble(String, int) 1 failed");
1877 assertEquals(5.0d, NumberUtils.toDouble("a", 5.0d), "toDouble(String, int) 2 failed");
1878
1879 assertEquals(1.2345d, NumberUtils.toDouble("001.2345", 5.1d), "toDouble(String, int) 3 failed");
1880 assertEquals(NumberUtils.toDouble("-001.2345", 5.1d), -1.2345d, "toDouble(String, int) 4 failed");
1881 assertEquals(1.2345d, NumberUtils.toDouble("+001.2345", 5.1d), "toDouble(String, int) 5 failed");
1882 assertEquals(0d, NumberUtils.toDouble("000.00", 5.1d), "toDouble(String, int) 7 failed");
1883 assertEquals(5.1d, NumberUtils.toDouble("", 5.1d));
1884 assertEquals(5.1d, NumberUtils.toDouble((String) null, 5.1d));
1885 }
1886
1887
1888
1889
1890 @Test
1891 void testToByteString() {
1892 assertEquals(123, NumberUtils.toByte("123"), "toByte(String) 1 failed");
1893 assertEquals(0, NumberUtils.toByte("abc"), "toByte(String) 2 failed");
1894 assertEquals(0, NumberUtils.toByte(""), "toByte(empty) failed");
1895 assertEquals(0, NumberUtils.toByte(null), "toByte(null) failed");
1896 }
1897
1898
1899
1900
1901 @Test
1902 void testToByteStringI() {
1903 assertEquals(123, NumberUtils.toByte("123", (byte) 5), "toByte(String, byte) 1 failed");
1904 assertEquals(5, NumberUtils.toByte("12.3", (byte) 5), "toByte(String, byte) 2 failed");
1905 assertEquals(5, NumberUtils.toByte("", (byte) 5));
1906 assertEquals(5, NumberUtils.toByte(null, (byte) 5));
1907 }
1908
1909
1910
1911
1912 @Test
1913 void testToFloatString() {
1914 assertEquals(NumberUtils.toFloat("-1.2345"), -1.2345f, "toFloat(String) 1 failed");
1915 assertEquals(1.2345f, NumberUtils.toFloat("1.2345"), "toFloat(String) 2 failed");
1916 assertEquals(0.0f, NumberUtils.toFloat("abc"), "toFloat(String) 3 failed");
1917
1918 assertEquals(NumberUtils.toFloat("-001.2345"), -1.2345f, "toFloat(String) 4 failed");
1919 assertEquals(1.2345f, NumberUtils.toFloat("+001.2345"), "toFloat(String) 5 failed");
1920 assertEquals(1.2345f, NumberUtils.toFloat("001.2345"), "toFloat(String) 6 failed");
1921 assertEquals(0f, NumberUtils.toFloat("000.00"), "toFloat(String) 7 failed");
1922 assertEquals(NumberUtils.toFloat(Float.MAX_VALUE + ""), Float.MAX_VALUE, "toFloat(Float.MAX_VALUE) failed");
1923 assertEquals(NumberUtils.toFloat(Float.MIN_VALUE + ""), Float.MIN_VALUE, "toFloat(Float.MIN_VALUE) failed");
1924 assertEquals(0.0f, NumberUtils.toFloat(""), "toFloat(empty) failed");
1925 assertEquals(0.0f, NumberUtils.toFloat(null), "toFloat(null) failed");
1926 }
1927
1928
1929
1930
1931 @Test
1932 void testToFloatStringF() {
1933 assertEquals(1.2345f, NumberUtils.toFloat("1.2345", 5.1f), "toFloat(String, int) 1 failed");
1934 assertEquals(5.0f, NumberUtils.toFloat("a", 5.0f), "toFloat(String, int) 2 failed");
1935
1936 assertEquals(5.0f, NumberUtils.toFloat("-001Z.2345", 5.0f), "toFloat(String, int) 3 failed");
1937 assertEquals(5.0f, NumberUtils.toFloat("+001AB.2345", 5.0f), "toFloat(String, int) 4 failed");
1938 assertEquals(5.0f, NumberUtils.toFloat("001Z.2345", 5.0f), "toFloat(String, int) 5 failed");
1939 assertEquals(5.0f, NumberUtils.toFloat("", 5.0f));
1940 assertEquals(5.0f, NumberUtils.toFloat(null, 5.0f));
1941 }
1942
1943
1944
1945
1946 @Test
1947 void testToIntString() {
1948 assertEquals(12345, NumberUtils.toInt("12345"), "toInt(String) 1 failed");
1949 assertEquals(0, NumberUtils.toInt("abc"), "toInt(String) 2 failed");
1950 assertEquals(0, NumberUtils.toInt(""), "toInt(empty) failed");
1951 assertEquals(0, NumberUtils.toInt(null), "toInt(null) failed");
1952 }
1953
1954
1955
1956
1957 @Test
1958 void testToIntStringI() {
1959 assertEquals(12345, NumberUtils.toInt("12345", 5), "toInt(String, int) 1 failed");
1960 assertEquals(5, NumberUtils.toInt("1234.5", 5), "toInt(String, int) 2 failed");
1961 assertEquals(5, NumberUtils.toInt("", 5));
1962 assertEquals(5, NumberUtils.toInt(null, 5));
1963 }
1964
1965
1966
1967
1968 @Test
1969 void testToLongString() {
1970 assertEquals(12345L, NumberUtils.toLong("12345"), "toLong(String) 1 failed");
1971 assertEquals(0L, NumberUtils.toLong("abc"), "toLong(String) 2 failed");
1972 assertEquals(0L, NumberUtils.toLong("1L"), "toLong(String) 3 failed");
1973 assertEquals(0L, NumberUtils.toLong("1l"), "toLong(String) 4 failed");
1974 assertEquals(NumberUtils.toLong(Long.MAX_VALUE + ""), Long.MAX_VALUE, "toLong(Long.MAX_VALUE) failed");
1975 assertEquals(NumberUtils.toLong(Long.MIN_VALUE + ""), Long.MIN_VALUE, "toLong(Long.MIN_VALUE) failed");
1976 assertEquals(0L, NumberUtils.toLong(""), "toLong(empty) failed");
1977 assertEquals(0L, NumberUtils.toLong(null), "toLong(null) failed");
1978 }
1979
1980
1981
1982
1983 @Test
1984 void testToLongStringL() {
1985 assertEquals(12345L, NumberUtils.toLong("12345", 5L), "toLong(String, long) 1 failed");
1986 assertEquals(5L, NumberUtils.toLong("1234.5", 5L), "toLong(String, long) 2 failed");
1987 assertEquals(5L, NumberUtils.toLong("", 5L));
1988 assertEquals(5L, NumberUtils.toLong(null, 5L));
1989 }
1990
1991
1992
1993
1994 @Test
1995 void testToScaledBigDecimalBigDecimal() {
1996 assertEquals(NumberUtils.toScaledBigDecimal(BigDecimal.valueOf(123.456)), BigDecimal.valueOf(123.46), "toScaledBigDecimal(BigDecimal) 1 failed");
1997
1998 assertEquals(NumberUtils.toScaledBigDecimal(BigDecimal.valueOf(23.515)), BigDecimal.valueOf(23.52), "toScaledBigDecimal(BigDecimal) 2 failed");
1999 assertEquals(NumberUtils.toScaledBigDecimal(BigDecimal.valueOf(23.525)), BigDecimal.valueOf(23.52), "toScaledBigDecimal(BigDecimal) 3 failed");
2000 assertEquals("2352.00", NumberUtils.toScaledBigDecimal(BigDecimal.valueOf(23.525)).multiply(BigDecimal.valueOf(100)).toString(),
2001 "toScaledBigDecimal(BigDecimal) 4 failed");
2002 assertEquals(NumberUtils.toScaledBigDecimal((BigDecimal) null), BigDecimal.ZERO, "toScaledBigDecimal(BigDecimal) 5 failed");
2003 }
2004
2005
2006
2007
2008 @Test
2009 void testToScaledBigDecimalBigDecimalIRM() {
2010 assertEquals(NumberUtils.toScaledBigDecimal(BigDecimal.valueOf(123.456), 1, RoundingMode.CEILING), BigDecimal.valueOf(123.5),
2011 "toScaledBigDecimal(BigDecimal, int, RoundingMode) 1 failed");
2012 assertEquals(NumberUtils.toScaledBigDecimal(BigDecimal.valueOf(23.5159), 3, RoundingMode.FLOOR), BigDecimal.valueOf(23.515),
2013 "toScaledBigDecimal(BigDecimal, int, RoundingMode) 2 failed");
2014 assertEquals(NumberUtils.toScaledBigDecimal(BigDecimal.valueOf(23.525), 2, RoundingMode.HALF_UP), BigDecimal.valueOf(23.53),
2015 "toScaledBigDecimal(BigDecimal, int, RoundingMode) 3 failed");
2016 assertEquals("23521.0000",
2017 NumberUtils.toScaledBigDecimal(BigDecimal.valueOf(23.521), 4, RoundingMode.HALF_EVEN).multiply(BigDecimal.valueOf(1000)).toString(),
2018 "toScaledBigDecimal(BigDecimal, int, RoundingMode) 4 failed");
2019 assertEquals(NumberUtils.toScaledBigDecimal((BigDecimal) null, 2, RoundingMode.HALF_UP), BigDecimal.ZERO,
2020 "toScaledBigDecimal(BigDecimal, int, RoundingMode) 5 failed");
2021 }
2022
2023
2024
2025
2026 @Test
2027 void testToScaledBigDecimalDouble() {
2028 assertEquals(NumberUtils.toScaledBigDecimal(Double.valueOf(123.456d)), BigDecimal.valueOf(123.46), "toScaledBigDecimal(Double) 1 failed");
2029
2030 assertEquals(NumberUtils.toScaledBigDecimal(Double.valueOf(23.515d)), BigDecimal.valueOf(23.52), "toScaledBigDecimal(Double) 2 failed");
2031 assertEquals(NumberUtils.toScaledBigDecimal(Double.valueOf(23.525d)), BigDecimal.valueOf(23.52), "toScaledBigDecimal(Double) 3 failed");
2032 assertEquals("2352.00", NumberUtils.toScaledBigDecimal(Double.valueOf(23.525d)).multiply(BigDecimal.valueOf(100)).toString(),
2033 "toScaledBigDecimal(Double) 4 failed");
2034 assertEquals(NumberUtils.toScaledBigDecimal((Double) null), BigDecimal.ZERO, "toScaledBigDecimal(Double) 5 failed");
2035 }
2036
2037
2038
2039
2040 @Test
2041 void testToScaledBigDecimalDoubleIRM() {
2042 assertEquals(NumberUtils.toScaledBigDecimal(Double.valueOf(123.456d), 1, RoundingMode.CEILING), BigDecimal.valueOf(123.5),
2043 "toScaledBigDecimal(Double, int, RoundingMode) 1 failed");
2044 assertEquals(NumberUtils.toScaledBigDecimal(Double.valueOf(23.5159d), 3, RoundingMode.FLOOR), BigDecimal.valueOf(23.515),
2045 "toScaledBigDecimal(Double, int, RoundingMode) 2 failed");
2046 assertEquals(NumberUtils.toScaledBigDecimal(Double.valueOf(23.525d), 2, RoundingMode.HALF_UP), BigDecimal.valueOf(23.53),
2047 "toScaledBigDecimal(Double, int, RoundingMode) 3 failed");
2048 assertEquals("23521.0000",
2049 NumberUtils.toScaledBigDecimal(Double.valueOf(23.521d), 4, RoundingMode.HALF_EVEN).multiply(BigDecimal.valueOf(1000)).toString(),
2050 "toScaledBigDecimal(Double, int, RoundingMode) 4 failed");
2051 assertEquals(NumberUtils.toScaledBigDecimal((Double) null, 2, RoundingMode.HALF_UP), BigDecimal.ZERO,
2052 "toScaledBigDecimal(Double, int, RoundingMode) 5 failed");
2053 }
2054
2055
2056
2057
2058 @Test
2059 void testToScaledBigDecimalFloat() {
2060 assertEquals(NumberUtils.toScaledBigDecimal(Float.valueOf(123.456f)), BigDecimal.valueOf(123.46), "toScaledBigDecimal(Float) 1 failed");
2061
2062 assertEquals(NumberUtils.toScaledBigDecimal(Float.valueOf(23.515f)), BigDecimal.valueOf(23.51), "toScaledBigDecimal(Float) 2 failed");
2063
2064
2065 assertEquals(NumberUtils.toScaledBigDecimal(Float.valueOf(23.525f)), BigDecimal.valueOf(23.52), "toScaledBigDecimal(Float) 3 failed");
2066 assertEquals("2352.00", NumberUtils.toScaledBigDecimal(Float.valueOf(23.525f)).multiply(BigDecimal.valueOf(100)).toString(),
2067 "toScaledBigDecimal(Float) 4 failed");
2068 assertEquals(NumberUtils.toScaledBigDecimal((Float) null), BigDecimal.ZERO, "toScaledBigDecimal(Float) 5 failed");
2069 }
2070
2071
2072
2073
2074 @Test
2075 void testToScaledBigDecimalFloatIRM() {
2076 assertEquals(NumberUtils.toScaledBigDecimal(Float.valueOf(123.456f), 1, RoundingMode.CEILING), BigDecimal.valueOf(123.5),
2077 "toScaledBigDecimal(Float, int, RoundingMode) 1 failed");
2078 assertEquals(NumberUtils.toScaledBigDecimal(Float.valueOf(23.5159f), 3, RoundingMode.FLOOR), BigDecimal.valueOf(23.515),
2079 "toScaledBigDecimal(Float, int, RoundingMode) 2 failed");
2080
2081 assertEquals(NumberUtils.toScaledBigDecimal(Float.valueOf(23.525f), 2, RoundingMode.HALF_UP), BigDecimal.valueOf(23.52),
2082 "toScaledBigDecimal(Float, int, RoundingMode) 3 failed");
2083 assertEquals("23521.0000",
2084 NumberUtils.toScaledBigDecimal(Float.valueOf(23.521f), 4, RoundingMode.HALF_EVEN).multiply(BigDecimal.valueOf(1000)).toString(),
2085 "toScaledBigDecimal(Float, int, RoundingMode) 4 failed");
2086 assertEquals(NumberUtils.toScaledBigDecimal((Float) null, 2, RoundingMode.HALF_UP), BigDecimal.ZERO,
2087 "toScaledBigDecimal(Float, int, RoundingMode) 5 failed");
2088 }
2089
2090
2091
2092
2093 @Test
2094 void testToScaledBigDecimalString() {
2095 assertEquals(NumberUtils.toScaledBigDecimal("123.456"), BigDecimal.valueOf(123.46), "toScaledBigDecimal(String) 1 failed");
2096
2097 assertEquals(NumberUtils.toScaledBigDecimal("23.515"), BigDecimal.valueOf(23.52), "toScaledBigDecimal(String) 2 failed");
2098 assertEquals(NumberUtils.toScaledBigDecimal("23.525"), BigDecimal.valueOf(23.52), "toScaledBigDecimal(String) 3 failed");
2099 assertEquals("2352.00", NumberUtils.toScaledBigDecimal("23.525").multiply(BigDecimal.valueOf(100)).toString(), "toScaledBigDecimal(String) 4 failed");
2100 assertEquals(NumberUtils.toScaledBigDecimal((String) null), BigDecimal.ZERO, "toScaledBigDecimal(String) 5 failed");
2101 }
2102
2103
2104
2105
2106 @Test
2107 void testToScaledBigDecimalStringIRM() {
2108 assertEquals(NumberUtils.toScaledBigDecimal("123.456", 1, RoundingMode.CEILING), BigDecimal.valueOf(123.5),
2109 "toScaledBigDecimal(String, int, RoundingMode) 1 failed");
2110 assertEquals(NumberUtils.toScaledBigDecimal("23.5159", 3, RoundingMode.FLOOR), BigDecimal.valueOf(23.515),
2111 "toScaledBigDecimal(String, int, RoundingMode) 2 failed");
2112 assertEquals(NumberUtils.toScaledBigDecimal("23.525", 2, RoundingMode.HALF_UP), BigDecimal.valueOf(23.53),
2113 "toScaledBigDecimal(String, int, RoundingMode) 3 failed");
2114 assertEquals("23521.0000", NumberUtils.toScaledBigDecimal("23.521", 4, RoundingMode.HALF_EVEN).multiply(BigDecimal.valueOf(1000)).toString(),
2115 "toScaledBigDecimal(String, int, RoundingMode) 4 failed");
2116 assertEquals(NumberUtils.toScaledBigDecimal((String) null, 2, RoundingMode.HALF_UP), BigDecimal.ZERO,
2117 "toScaledBigDecimal(String, int, RoundingMode) 5 failed");
2118 }
2119
2120
2121
2122
2123 @Test
2124 void testToShortString() {
2125 assertEquals(12345, NumberUtils.toShort("12345"), "toShort(String) 1 failed");
2126 assertEquals(0, NumberUtils.toShort("abc"), "toShort(String) 2 failed");
2127 assertEquals(0, NumberUtils.toShort(""), "toShort(empty) failed");
2128 assertEquals(0, NumberUtils.toShort(null), "toShort(null) failed");
2129 }
2130
2131
2132
2133
2134 @Test
2135 void testToShortStringI() {
2136 assertEquals(12345, NumberUtils.toShort("12345", (short) 5), "toShort(String, short) 1 failed");
2137 assertEquals(5, NumberUtils.toShort("1234.5", (short) 5), "toShort(String, short) 2 failed");
2138 assertEquals(5, NumberUtils.toShort("", (short) 5));
2139 assertEquals(5, NumberUtils.toShort(null, (short) 5));
2140 }
2141 }