View Javadoc
1   /*
2    * Licensed to the Apache Software Foundation (ASF) under one or more
3    * contributor license agreements.  See the NOTICE file distributed with
4    * this work for additional information regarding copyright ownership.
5    * The ASF licenses this file to You under the Apache License, Version 2.0
6    * (the "License"); you may not use this file except in compliance with
7    * the License.  You may obtain a copy of the License at
8    *
9    *      https://www.apache.org/licenses/LICENSE-2.0
10   *
11   * Unless required by applicable law or agreed to in writing, software
12   * distributed under the License is distributed on an "AS IS" BASIS,
13   * WITHOUT WARRANTIES OR CONDITIONS OF ANY KIND, either express or implied.
14   * See the License for the specific language governing permissions and
15   * limitations under the License.
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   * Tests {@link NumberUtils}.
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             // Stops parsing when a space is found, then returns an object.
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             // Stops parsing when a space is found, then returns an object.
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      * Test for {@link NumberUtils#toDouble(BigDecimal)}
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      * Test for {@link NumberUtils#toDouble(BigDecimal, double)}
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     // Testing JDK against old Lang functionality
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") // suppress instanceof warning check
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             // @formatter:off
444             "",
445             " ",
446             "\b\t\n\f\r",
447             // Funky whitespaces
448             "\u00A0\uFEFF\u000B\u000C\u001C\u001D\u001E\u001F",
449             // sign alone not valid
450             "-",
451             // comment in NumberUtils suggests some implementations may incorrectly allow this
452             "--",
453             "--0",
454             // sign alone not valid
455             "+",
456             // in case this was also allowed by some JVMs
457             "++",
458             "++0" })
459             // @formatter:on
460     void testCreateBigDecimalFailure(final String str) {
461         assertThrows(NumberFormatException.class, () -> NumberUtils.createBigDecimal(str), "createBigDecimal(\"" + str + "\") should have failed.");
462         // Should match java.math.BigInteger.BigInteger(String)
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         // Funky whitespaces
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         // LANG-1645
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         // a doubled sign is not a valid number
485     }
486 
487     @ParameterizedTest
488     @ValueSource(strings = {
489             // @formatter:off
490             "",
491             " ",
492             "\b\t\n\f\r",
493             // Funky whitespaces
494             "\u00A0\uFEFF\u000B\u000C\u001C\u001D\u001E\u001F",
495             "#",
496             "-#",
497             "0x",
498             "-0x",
499             // a doubled sign is not a valid number
500             "--1",
501             "-+1",
502             "+-1",
503             "++1",
504             "--010",
505             "-0x-1" })
506             // @formatter:on
507     void testCreateBigIntegerFailure(final String str) {
508         assertThrows(NumberFormatException.class, () -> NumberUtils.createBigInteger(str), "createBigInteger(\"" + str + "\") should have failed.");
509         // Should match java.math.BigInteger.BigInteger(String)
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             // @formatter:off
525             "",
526             " ",
527             "\b\t\n\f\r",
528             // Funky whitespaces
529             "\u00A0\uFEFF\u000B\u000C\u001C\u001D\u001E\u001F" })
530             // @formatter:on
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             // @formatter:off
545             "",
546             " ",
547             "\b\t\n\f\r",
548             // Funky whitespaces
549             "\u00A0\uFEFF\u000B\u000C\u001C\u001D\u001E\u001F" })
550             // @formatter:on
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         // LANG-1645
561         assertEquals(Integer.decode("+0xF"), NumberUtils.createInteger("+0xF"));
562     }
563 
564     @ParameterizedTest
565     @ValueSource(strings = {
566             // @formatter:off
567             "",
568             " ",
569             "\b\t\n\f\r",
570             // Funky whitespaces
571             "\u00A0\uFEFF\u000B\u000C\u001C\u001D\u001E\u001F" })
572             // @formatter:on
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         // LANG-1645
583         assertEquals(Long.decode("+0xFFFFFFFF"), NumberUtils.createLong("+0xFFFFFFFF"));
584     }
585 
586     @ParameterizedTest
587     @ValueSource(strings = {
588             // @formatter:off
589             "",
590             " ",
591             "\b\t\n\f\r",
592             // Funky whitespaces
593             "\u00A0\uFEFF\u000B\u000C\u001C\u001D\u001E\u001F" })
594             // @formatter:on
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         // a lot of things can go wrong
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         // LANG-521
647         assertEquals(Float.valueOf("2."), NumberUtils.createNumber("2."), "createNumber(String) LANG-521 failed");
648         // LANG-638
649         assertFalse(checkCreateNumber("1eE"), "createNumber(String) succeeded");
650         // LANG-693
651         assertEquals(Double.valueOf(Double.MAX_VALUE), NumberUtils.createNumber("" + Double.MAX_VALUE), "createNumber(String) LANG-693 failed");
652         // LANG-822
653         // ensure that the underlying negative number would create a BigDecimal
654         final Number bigNum = NumberUtils.createNumber("-1.1E-700F");
655         assertNotNull(bigNum);
656         assertEquals(BigDecimal.class, bigNum.getClass());
657         // LANG-1018
658         assertEquals(Double.valueOf("-160952.54"), NumberUtils.createNumber("-160952.54"), "createNumber(String) LANG-1018 failed");
659         // LANG-1187
660         assertEquals(Double.valueOf("6264583.33"), NumberUtils.createNumber("6264583.33"), "createNumber(String) LANG-1187 failed");
661         // LANG-1215
662         assertEquals(Double.valueOf("193343.82"), NumberUtils.createNumber("193343.82"), "createNumber(String) LANG-1215 failed");
663         // LANG-1060
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         // LANG-1645
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         // A hex literal too large for a Long but carrying an explicit 'L'/'l' type suffix must drop the suffix
683         // before falling back to BigInteger, matching the decimal path (e.g. "12345678901234567890L").
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         // Map to a BigDecimal, not a Float.
690         assertEquals(new BigDecimal("0.100000001490116121"), NumberUtils.createNumber("0.100000001490116121"));
691     }
692 
693     @ParameterizedTest
694     @ValueSource(strings = { "", " ", "\t", "\r\n", "\u2003", "\u2003 \u2003", "\u00a0" })
695     void testCreateNumberBlank(final String str) {
696         assertThrows(NumberFormatException.class, () -> NumberUtils.createNumber(str));
697         compareIsCreatableWithCreateNumber(str, false);
698         compareIsNumberWithCreateNumber(str, false);
699     }
700 
701     @Test
702     // Check that the code fails to create a valid number when preceded by -- rather than -
703     void testCreateNumberFailure_1() {
704         assertThrows(NumberFormatException.class, () -> NumberUtils.createNumber("--1.1E-700F"));
705     }
706 
707     @Test
708     // Check that the code fails to create a valid number when both e and E are present (with decimal)
709     void testCreateNumberFailure_2() {
710         assertThrows(NumberFormatException.class, () -> NumberUtils.createNumber("-1.1E+0-7e00"));
711     }
712 
713     @Test
714     // Check that the code fails to create a valid number when both e and E are present (no decimal)
715     void testCreateNumberFailure_3() {
716         assertThrows(NumberFormatException.class, () -> NumberUtils.createNumber("-11E+0-7e00"));
717     }
718 
719     @Test
720     // Check that the code fails to create a valid number when both e and E are present (no decimal)
721     void testCreateNumberFailure_4() {
722         assertThrows(NumberFormatException.class, () -> NumberUtils.createNumber("1eE+00001"));
723     }
724 
725     @Test
726     // Check that the code fails to create a valid number when there are multiple trailing 'f' characters (LANG-1205)
727     void testCreateNumberFailure_5() {
728         assertThrows(NumberFormatException.class, () -> NumberUtils.createNumber("1234.5ff"));
729     }
730 
731     @Test
732     // Check that the code fails to create a valid number when there are multiple trailing 'F' characters (LANG-1205)
733     void testCreateNumberFailure_6() {
734         assertThrows(NumberFormatException.class, () -> NumberUtils.createNumber("1234.5FF"));
735     }
736 
737     @Test
738     // Check that the code fails to create a valid number when there are multiple trailing 'd' characters (LANG-1205)
739     void testCreateNumberFailure_7() {
740         assertThrows(NumberFormatException.class, () -> NumberUtils.createNumber("1234.5dd"));
741     }
742 
743     @Test
744     // Check that the code fails to create a valid number when there are multiple trailing 'D' characters (LANG-1205)
745     void testCreateNumberFailure_8() {
746         assertThrows(NumberFormatException.class, () -> NumberUtils.createNumber("1234.5DD"));
747     }
748 
749     /**
750      * Reject malformed signs in Long-suffixed numbers.
751      */
752     @Test
753     void testCreateNumberFailure_9() {
754         assertThrows(NumberFormatException.class, () -> NumberUtils.createNumber("++1L"));
755         assertThrows(NumberFormatException.class, () -> NumberUtils.createNumber("++1l"));
756         assertThrows(NumberFormatException.class, () -> NumberUtils.createNumber("--1L"));
757         assertThrows(NumberFormatException.class, () -> NumberUtils.createNumber("--1l"));
758         assertThrows(NumberFormatException.class, () -> NumberUtils.createNumber("+-1L"));
759         assertThrows(NumberFormatException.class, () -> NumberUtils.createNumber("-+1L"));
760         assertThrows(NumberFormatException.class, () -> NumberUtils.createNumber("+L"));
761         assertThrows(NumberFormatException.class, () -> NumberUtils.createNumber("-L"));
762     }
763 
764     @ParameterizedTest
765     @ValueSource(strings = { "1.5", ".5", "1e5", "1.5f", "1.5F", "1.5d", "1.5D", "+1.5", "-1.5" })
766     void testCreateNumberLeadingControlCharacters(final String str) {
767         for (char ch = 0; ch <= ' '; ch++) {
768             final String input = ch + str;
769             assertThrows(NumberFormatException.class, () -> NumberUtils.createNumber(input), () -> "Leading character: " + (int) input.charAt(0));
770             compareIsCreatableWithCreateNumber(input, false);
771             compareIsNumberWithCreateNumber(input, false);
772         }
773     }
774 
775     // Tests to show when magnitude causes switch to next Number type
776     // Will probably need to be adjusted if code is changed to check precision (LANG-693)
777     @Test
778     void testCreateNumberMagnitude() {
779         // Test Float.MAX_VALUE, and same with +1 in final digit to check conversion changes to next Number type
780         assertEquals(Float.valueOf(Float.MAX_VALUE), NumberUtils.createNumber("3.4028235e+38"));
781         assertEquals(Double.valueOf(3.4028236e+38), NumberUtils.createNumber("3.4028236e+38"));
782         // Test Double.MAX_VALUE
783         assertEquals(Double.valueOf(Double.MAX_VALUE), NumberUtils.createNumber("1.7976931348623157e+308"));
784         // Test with +2 in final digit (+1 does not cause roll-over to BigDecimal)
785         assertEquals(new BigDecimal("1.7976931348623159e+308"), NumberUtils.createNumber("1.7976931348623159e+308"));
786         // Requested type is parsed as zero but the value is not zero
787         final Double nonZero1 = Double.valueOf((double) Float.MIN_VALUE / 2);
788         assertEquals(nonZero1, NumberUtils.createNumber(nonZero1.toString()));
789         assertEquals(nonZero1, NumberUtils.createNumber(nonZero1 + "F"));
790         // Smallest double is 4.9e-324.
791         // Test a number with zero before and/or after the decimal place to hit edge cases.
792         final BigDecimal nonZero2 = new BigDecimal("4.9e-325");
793         assertEquals(nonZero2, NumberUtils.createNumber("4.9e-325"));
794         assertEquals(nonZero2, NumberUtils.createNumber("4.9e-325D"));
795         final BigDecimal nonZero3 = new BigDecimal("1e-325");
796         assertEquals(nonZero3, NumberUtils.createNumber("1e-325"));
797         assertEquals(nonZero3, NumberUtils.createNumber("1e-325D"));
798         final BigDecimal nonZero4 = new BigDecimal("0.1e-325");
799         assertEquals(nonZero4, NumberUtils.createNumber("0.1e-325"));
800         assertEquals(nonZero4, NumberUtils.createNumber("0.1e-325D"));
801         assertEquals(Integer.valueOf(0x12345678), NumberUtils.createNumber("0x12345678"));
802         assertEquals(Long.valueOf(0x123456789L), NumberUtils.createNumber("0x123456789"));
803         assertEquals(Long.valueOf(0x7fffffffffffffffL), NumberUtils.createNumber("0x7fffffffffffffff"));
804         // Does not appear to be a way to create a literal BigInteger of this magnitude
805         assertEquals(new BigInteger("7fffffffffffffff0", 16), NumberUtils.createNumber("0x7fffffffffffffff0"));
806         assertEquals(Long.valueOf(0x7fffffffffffffffL), NumberUtils.createNumber("#7fffffffffffffff"));
807         assertEquals(new BigInteger("7fffffffffffffff0", 16), NumberUtils.createNumber("#7fffffffffffffff0"));
808         assertEquals(Integer.valueOf(017777777777), NumberUtils.createNumber("017777777777")); // 31 bits
809         assertEquals(Long.valueOf(037777777777L), NumberUtils.createNumber("037777777777")); // 32 bits
810         // 63 bits
811         assertEquals(Long.valueOf(0777777777777777777777L), NumberUtils.createNumber("0777777777777777777777"));
812         // 64 bits
813         assertEquals(new BigInteger("1777777777777777777777", 8), NumberUtils.createNumber("01777777777777777777777"));
814     }
815 
816     /**
817      * LANG-1646: Support the requested Number type (Long, Float, Double) of valid zero input.
818      */
819     @Test
820     void testCreateNumberZero() {
821         // Handle integers
822         assertEquals(Integer.valueOf(0), NumberUtils.createNumber("0"));
823         assertEquals(Integer.valueOf(0), NumberUtils.createNumber("-0"));
824         assertEquals(Long.valueOf(0), NumberUtils.createNumber("0L"));
825         assertEquals(Long.valueOf(0), NumberUtils.createNumber("-0L"));
826         // Handle floating-point with optional leading sign, trailing exponent (eX)
827         // and format specifier (F or D).
828         // This should allow: 0. ; .0 ; 0.0 ; 0 (if exponent or format specifier is present)
829         // Exponent does not matter for zero
830         final int[] exponents = { -2345, 0, 13 };
831         final String[] zeros = { "0.", ".0", "0.0", "0" };
832         final Float f0 = Float.valueOf(0);
833         final Float fn0 = Float.valueOf(-0F);
834         final Double d0 = Double.valueOf(0);
835         final Double dn0 = Double.valueOf(-0D);
836         for (final String zero : zeros) {
837             // Assume float if no preference.
838             // This requires a decimal point if there is no exponent.
839             if (zero.indexOf('.') != -1) {
840                 assertCreateNumberZero(zero, f0, fn0);
841             }
842             for (final int exp : exponents) {
843                 assertCreateNumberZero(zero + "e" + exp, f0, fn0);
844             }
845             // Type preference
846             assertCreateNumberZero(zero + "F", f0, fn0);
847             assertCreateNumberZero(zero + "D", d0, dn0);
848             for (final int exp : exponents) {
849                 final String number = zero + "e" + exp;
850                 assertCreateNumberZero(number + "F", f0, fn0);
851                 assertCreateNumberZero(number + "D", d0, dn0);
852             }
853         }
854     }
855 
856     @Test
857     void testInvalidNumber() {
858         assertThrows(NumberFormatException.class, () -> NumberUtils.createNumber("E123e.3"));
859         assertThrows(NumberFormatException.class, () -> NumberUtils.createNumber("-"));
860     }
861 
862     /**
863      * Tests isCreatable(String) and tests that createNumber(String) returns a valid number iff isCreatable(String) returns false.
864      */
865     @Test
866     void testIsCreatable() {
867         compareIsCreatableWithCreateNumber("12345", true);
868         compareIsCreatableWithCreateNumber("1234.5", true);
869         compareIsCreatableWithCreateNumber(".12345", true);
870         compareIsCreatableWithCreateNumber("1234E5", true);
871         compareIsCreatableWithCreateNumber("1234E+5", true);
872         compareIsCreatableWithCreateNumber("1234E-5", true);
873         compareIsCreatableWithCreateNumber("123.4E5", true);
874         compareIsCreatableWithCreateNumber("-1234", true);
875         compareIsCreatableWithCreateNumber("-1234.5", true);
876         compareIsCreatableWithCreateNumber("-.12345", true);
877         compareIsCreatableWithCreateNumber("-1234E5", true);
878         compareIsCreatableWithCreateNumber("0", true);
879         compareIsCreatableWithCreateNumber("0.1", true); // LANG-1216
880         compareIsCreatableWithCreateNumber("-0", true);
881         compareIsCreatableWithCreateNumber("01234", true);
882         compareIsCreatableWithCreateNumber("-01234", true);
883         compareIsCreatableWithCreateNumber("-0xABC123", true);
884         compareIsCreatableWithCreateNumber("-0x0", true);
885         compareIsCreatableWithCreateNumber("123.4E21D", true);
886         compareIsCreatableWithCreateNumber("-221.23F", true);
887         compareIsCreatableWithCreateNumber("22338L", true);
888         compareIsCreatableWithCreateNumber("+22338L", true);
889         compareIsCreatableWithCreateNumber("+22338l", true);
890         compareIsCreatableWithCreateNumber("+0L", true);
891         compareIsCreatableWithCreateNumber("+0l", true);
892         compareIsCreatableWithCreateNumber("+" + Long.MAX_VALUE + "L", true);
893         compareIsCreatableWithCreateNumber("+" + Long.MAX_VALUE + "l", true);
894         compareIsCreatableWithCreateNumber(Long.MAX_VALUE + "L", true);
895         compareIsCreatableWithCreateNumber(Long.MAX_VALUE + "l", true);
896         compareIsCreatableWithCreateNumber(Long.MIN_VALUE + "L", true);
897         compareIsCreatableWithCreateNumber(Long.MIN_VALUE + "l", true);
898         compareIsCreatableWithCreateNumber("+" + BigInteger.valueOf(Long.MAX_VALUE).add(BigInteger.ONE) + "L", true);
899         compareIsCreatableWithCreateNumber("+" + BigInteger.valueOf(Long.MAX_VALUE).add(BigInteger.ONE) + "l", true);
900         compareIsCreatableWithCreateNumber("+12345678901234567890L", true);
901         compareIsCreatableWithCreateNumber(null, false);
902         compareIsCreatableWithCreateNumber("", false);
903         compareIsCreatableWithCreateNumber(" ", false);
904         compareIsCreatableWithCreateNumber("\r\n\t", false);
905         compareIsCreatableWithCreateNumber("--2.3", false);
906         compareIsCreatableWithCreateNumber("--2", false);
907         compareIsCreatableWithCreateNumber("-+2", false);
908         compareIsCreatableWithCreateNumber("+-2", false);
909         compareIsCreatableWithCreateNumber("++2", false);
910         compareIsCreatableWithCreateNumber("++1L", false);
911         compareIsCreatableWithCreateNumber("++1l", false);
912         compareIsCreatableWithCreateNumber("--1L", false);
913         compareIsCreatableWithCreateNumber("--1l", false);
914         compareIsCreatableWithCreateNumber("+-1L", false);
915         compareIsCreatableWithCreateNumber("-+1L", false);
916         compareIsCreatableWithCreateNumber("+L", false);
917         compareIsCreatableWithCreateNumber("-L", false);
918         compareIsCreatableWithCreateNumber(".12.3", false);
919         compareIsCreatableWithCreateNumber("-123E", false);
920         compareIsCreatableWithCreateNumber("-123E+-212", false);
921         compareIsCreatableWithCreateNumber("-123E2.12", false);
922         compareIsCreatableWithCreateNumber("0xGF", false);
923         compareIsCreatableWithCreateNumber("0xFAE-1", false);
924         compareIsCreatableWithCreateNumber(".", false);
925         compareIsCreatableWithCreateNumber("-0ABC123", false);
926         compareIsCreatableWithCreateNumber("123.4E-D", false);
927         compareIsCreatableWithCreateNumber("123.4ED", false);
928         compareIsCreatableWithCreateNumber("1234E5l", false);
929         compareIsCreatableWithCreateNumber("11a", false);
930         compareIsCreatableWithCreateNumber("1a", false);
931         compareIsCreatableWithCreateNumber("a", false);
932         compareIsCreatableWithCreateNumber("11g", false);
933         compareIsCreatableWithCreateNumber("11z", false);
934         compareIsCreatableWithCreateNumber("11def", false);
935         compareIsCreatableWithCreateNumber("11d11", false);
936         compareIsCreatableWithCreateNumber("11 11", false);
937         compareIsCreatableWithCreateNumber(" 1111", false);
938         compareIsCreatableWithCreateNumber("1111 ", false);
939         compareIsCreatableWithCreateNumber(" 1.5", false);
940         compareIsCreatableWithCreateNumber("\t1.5", false);
941         compareIsCreatableWithCreateNumber(" .5", false);
942         compareIsCreatableWithCreateNumber(" 1e5", false);
943         compareIsCreatableWithCreateNumber(" 1.5f", false);
944         compareIsCreatableWithCreateNumber(" 1.5d", false);
945         compareIsCreatableWithCreateNumber(" 1.5E3D", false);
946         compareIsCreatableWithCreateNumber("1.5 ", false);
947         compareIsCreatableWithCreateNumber("1.5f ", false);
948         compareIsCreatableWithCreateNumber("2.", true); // LANG-521
949         compareIsCreatableWithCreateNumber("1.1L", false); // LANG-664
950         compareIsCreatableWithCreateNumber("+0xF", true); // LANG-1645
951         compareIsCreatableWithCreateNumber("+0xFFFFFFFF", true); // LANG-1645
952         compareIsCreatableWithCreateNumber("+0xFFFFFFFFFFFFFFFF", true); // LANG-1645
953         compareIsCreatableWithCreateNumber(".0", true); // LANG-1646
954         compareIsCreatableWithCreateNumber("0.", true); // LANG-1646
955         compareIsCreatableWithCreateNumber("0.D", true); // LANG-1646
956         compareIsCreatableWithCreateNumber("0e1", true); // LANG-1646
957         compareIsCreatableWithCreateNumber("0e1D", true); // LANG-1646
958         compareIsCreatableWithCreateNumber(".D", false); // LANG-1646
959         compareIsCreatableWithCreateNumber(".e10", false); // LANG-1646
960         compareIsCreatableWithCreateNumber(".e10D", false); // LANG-1646
961         compareIsCreatableWithCreateNumber("1E2147483647", true);
962         compareIsCreatableWithCreateNumber("1E+2147483647", true);
963         compareIsCreatableWithCreateNumber("1E-2147483647", true);
964         compareIsCreatableWithCreateNumber("1E-2147483648", false);
965         compareIsCreatableWithCreateNumber("1E2147483648", SystemUtils.isJavaVersionAtLeast(JavaVersion.JAVA_21));
966         compareIsCreatableWithCreateNumber("1E+2147483648", SystemUtils.isJavaVersionAtLeast(JavaVersion.JAVA_21));
967         compareIsCreatableWithCreateNumber("1E+2147483649", false);
968         compareIsCreatableWithCreateNumber("1E-2147483649", false);
969         compareIsCreatableWithCreateNumber("1E2147483648D", SystemUtils.isJavaVersionAtLeast(JavaVersion.JAVA_21));
970         compareIsCreatableWithCreateNumber("1E-2147483648D", false);
971         compareIsCreatableWithCreateNumber("1E2147483648F", SystemUtils.isJavaVersionAtLeast(JavaVersion.JAVA_21));
972         compareIsCreatableWithCreateNumber("1E+2147483648F", SystemUtils.isJavaVersionAtLeast(JavaVersion.JAVA_21));
973         compareIsCreatableWithCreateNumber("1E-2147483648F", false);
974         compareIsCreatableWithCreateNumber("1.0E2147483648", SystemUtils.isJavaVersionAtLeast(JavaVersion.JAVA_21));
975         compareIsCreatableWithCreateNumber("1.0E-2147483648", false);
976         compareIsCreatableWithCreateNumber("1E+999999999999999999999", false);
977         compareIsCreatableWithCreateNumber("1E-999999999999999999999", false);
978         compareIsCreatableWithCreateNumber("0.100000001490116121", true);
979     }
980 
981     @Test
982     void testIsDigits() {
983         assertFalse(NumberUtils.isDigits(null), "isDigits(null) failed");
984         assertFalse(NumberUtils.isDigits(""), "isDigits('') failed");
985         assertTrue(NumberUtils.isDigits("12345"), "isDigits(String) failed");
986         assertFalse(NumberUtils.isDigits("1234.5"), "isDigits(String) neg 1 failed");
987         assertFalse(NumberUtils.isDigits("1ab"), "isDigits(String) neg 3 failed");
988         assertFalse(NumberUtils.isDigits("abc"), "isDigits(String) neg 4 failed");
989     }
990 
991     /**
992      * Tests isCreatable(String) and tests that createNumber(String) returns a valid number iff isCreatable(String) returns false.
993      */
994     @Test
995     void testIsNumber() {
996         compareIsNumberWithCreateNumber("12345", true);
997         compareIsNumberWithCreateNumber("1234.5", true);
998         compareIsNumberWithCreateNumber(".12345", true);
999         compareIsNumberWithCreateNumber("1234E5", true);
1000         compareIsNumberWithCreateNumber("1234E+5", true);
1001         compareIsNumberWithCreateNumber("1234E-5", true);
1002         compareIsNumberWithCreateNumber("123.4E5", true);
1003         compareIsNumberWithCreateNumber("-1234", true);
1004         compareIsNumberWithCreateNumber("-1234.5", true);
1005         compareIsNumberWithCreateNumber("-.12345", true);
1006         compareIsNumberWithCreateNumber("-0001.12345", true);
1007         compareIsNumberWithCreateNumber("-000.12345", true);
1008         compareIsNumberWithCreateNumber("+00.12345", true);
1009         compareIsNumberWithCreateNumber("+0002.12345", true);
1010         compareIsNumberWithCreateNumber("-1234E5", true);
1011         compareIsNumberWithCreateNumber("0", true);
1012         compareIsNumberWithCreateNumber("-0", true);
1013         compareIsNumberWithCreateNumber("01234", true);
1014         compareIsNumberWithCreateNumber("-01234", true);
1015         compareIsNumberWithCreateNumber("-0xABC123", true);
1016         compareIsNumberWithCreateNumber("-0x0", true);
1017         compareIsNumberWithCreateNumber("123.4E21D", true);
1018         compareIsNumberWithCreateNumber("-221.23F", true);
1019         compareIsNumberWithCreateNumber("22338L", true);
1020         compareIsNumberWithCreateNumber(null, false);
1021         compareIsNumberWithCreateNumber("", false);
1022         compareIsNumberWithCreateNumber(" ", false);
1023         compareIsNumberWithCreateNumber("\r\n\t", false);
1024         compareIsNumberWithCreateNumber("--2.3", false);
1025         compareIsNumberWithCreateNumber(".12.3", false);
1026         compareIsNumberWithCreateNumber("-123E", false);
1027         compareIsNumberWithCreateNumber("-123E+-212", false);
1028         compareIsNumberWithCreateNumber("-123E2.12", false);
1029         compareIsNumberWithCreateNumber("0xGF", false);
1030         compareIsNumberWithCreateNumber("0xFAE-1", false);
1031         compareIsNumberWithCreateNumber(".", false);
1032         compareIsNumberWithCreateNumber("-0ABC123", false);
1033         compareIsNumberWithCreateNumber("123.4E-D", false);
1034         compareIsNumberWithCreateNumber("123.4ED", false);
1035         compareIsNumberWithCreateNumber("+000E.12345", false);
1036         compareIsNumberWithCreateNumber("-000E.12345", false);
1037         compareIsNumberWithCreateNumber("1234E5l", false);
1038         compareIsNumberWithCreateNumber("11a", false);
1039         compareIsNumberWithCreateNumber("1a", false);
1040         compareIsNumberWithCreateNumber("a", false);
1041         compareIsNumberWithCreateNumber("11g", false);
1042         compareIsNumberWithCreateNumber("11z", false);
1043         compareIsNumberWithCreateNumber("11def", false);
1044         compareIsNumberWithCreateNumber("11d11", false);
1045         compareIsNumberWithCreateNumber("11 11", false);
1046         compareIsNumberWithCreateNumber(" 1111", false);
1047         compareIsNumberWithCreateNumber("1111 ", false);
1048         compareIsNumberWithCreateNumber(" 1.5", false);
1049         compareIsNumberWithCreateNumber(" 1.5d", false);
1050         compareIsNumberWithCreateNumber("2.", true); // LANG-521
1051         compareIsNumberWithCreateNumber("1.1L", false); // LANG-664
1052         compareIsNumberWithCreateNumber("+0xF", true); // LANG-1645
1053         compareIsNumberWithCreateNumber("+0xFFFFFFFF", true); // LANG-1645
1054         compareIsNumberWithCreateNumber("+0xFFFFFFFFFFFFFFFF", true); // LANG-1645
1055         compareIsNumberWithCreateNumber(".0", true); // LANG-1646
1056         compareIsNumberWithCreateNumber("0.", true); // LANG-1646
1057         compareIsNumberWithCreateNumber("0.D", true); // LANG-1646
1058         compareIsNumberWithCreateNumber("0e1", true); // LANG-1646
1059         compareIsNumberWithCreateNumber("0e1D", true); // LANG-1646
1060         compareIsNumberWithCreateNumber(".D", false); // LANG-1646
1061         compareIsNumberWithCreateNumber(".e10", false); // LANG-1646
1062         compareIsNumberWithCreateNumber(".e10D", false); // LANG-1646
1063     }
1064 
1065     @Test
1066     void testIsNumberLANG1252() {
1067         compareIsNumberWithCreateNumber("+2", true);
1068         compareIsNumberWithCreateNumber("+2.0", true);
1069     }
1070 
1071     @Test
1072     void testIsNumberLANG1385() {
1073         compareIsNumberWithCreateNumber("L", false);
1074     }
1075 
1076     @Test
1077     void testIsNumberLANG971() {
1078         compareIsNumberWithCreateNumber("0085", false);
1079         compareIsNumberWithCreateNumber("085", false);
1080         compareIsNumberWithCreateNumber("08", false);
1081         compareIsNumberWithCreateNumber("07", true);
1082         compareIsNumberWithCreateNumber("00", true);
1083     }
1084 
1085     @Test
1086     void testIsNumberLANG972() {
1087         compareIsNumberWithCreateNumber("0xABCD", true);
1088         compareIsNumberWithCreateNumber("0XABCD", true);
1089     }
1090 
1091     @Test
1092     void testIsNumberLANG992() {
1093         compareIsNumberWithCreateNumber("0.0", true);
1094         compareIsNumberWithCreateNumber("0.4790", true);
1095     }
1096 
1097     @ParameterizedTest
1098     // @formatter:off
1099     @ValueSource(strings = {
1100             // Decimal floating-point literals (no suffix or 'd'/'D' suffix)
1101             "3.14",
1102             "3.14d",
1103             "3.14D",
1104             ".5",
1105             ".5d",
1106             "5.",
1107             "5.d",
1108             "5d",
1109             "0.0",
1110             "0.0d",
1111             // Exponential (scientific) notation
1112             "1.23e10",
1113             "1.23e10d",
1114             "1.23E10",
1115             "1.23e-10",
1116             "1.23e-10d",
1117             "1e5",
1118             "1e5d",
1119             ".5e3",
1120             ".5e3d",
1121             // Hexadecimal floating-point literals
1122             "0x1.8p3",
1123             "0x1.8p3d",
1124             "0x.8p0",
1125             "0x1p-3",
1126             "0x1.fffffffffffffp1023",
1127             "0x1.fffffffffffffp1023d",
1128             // With leading zeros
1129             "01.5",
1130             "01.5d" })
1131     // @formatter:on
1132     void testIsParsableDoubleTrue(final String input) {
1133         Double.parseDouble(input);
1134         assertTrue(NumberUtils.isParsable(input));
1135     }
1136 
1137     @ParameterizedTest
1138     @ValueSource(strings = { "", "0xC1AB", "65CBA2", "pendro", "64, 2", "64.2.2", "64..", "64L", "-", "--2",
1139             // Invalid scientific notation.
1140             "e5", "1e", "1e+", "1e-", "1ee5", "1e5e5",
1141             // Invalid type suffixes.
1142             "f", "d", "-f", "-d", })
1143     void testIsParsableFalse(final String input) {
1144         assertFalse(NumberUtils.isParsable(input));
1145     }
1146 
1147     @ParameterizedTest
1148     // @formatter:off
1149     @ValueSource(strings = {
1150             // Decimal floating-point literals
1151             "3.14f",
1152             "3.14F",
1153             ".5f",
1154             "5.f",
1155             "5f",
1156             "0.0f",
1157             // Exponential (scientific) notation
1158             "1.23e10f",
1159             "1.23E10f",
1160             "1.23e-10f",
1161             "1e5f",
1162             ".5e3f",
1163             // Hexadecimal floating-point literals
1164             "0x1.8p3f",
1165             "0x.8p0f",
1166             "0x1p-3f",
1167             "0x1.fffffep127f",
1168             // With leading zeros
1169             "01.5f"})
1170     // @formatter:on
1171     void testIsParsableFloatTrue(final String input) {
1172         Float.parseFloat(input);
1173         assertTrue(NumberUtils.isParsable(input));
1174     }
1175 
1176     /**
1177      * Tests https://issues.apache.org/jira/browse/LANG-1729 See https://bugs.openjdk.org/browse/JDK-8326627 <blockquote>From
1178      * https://docs.oracle.com/javase%2F9%2Fdocs%2Fapi%2F%2F/java/lang/Float.html#valueOf-java.lang.String-,
1179      * https://docs.oracle.com/javase/specs/jls/se8/html/jls-3.html#jls-3.10.2, and https://docs.oracle.com/javase/specs/jls/se8/html/jls-3.html#jls-Digits,
1180      * fullwidth Unicode digits are not applicable. Moved to JDK as an enhancement.</blockquote>
1181      */
1182     @Test
1183     void testIsParsableFullWidthUnicodeJDK8326627() {
1184         // 123 in fullwidth Unicode digits
1185         final String fullWidth123 = "\uFF10\uFF11\uFF12";
1186         assertThrows(NumberFormatException.class, () -> Double.parseDouble(fullWidth123));
1187         assertThrows(NumberFormatException.class, () -> Float.parseFloat(fullWidth123));
1188         assertTrue(NumberUtils.isParsable(fullWidth123));
1189         assertFalse(NumberUtils.isParsable(fullWidth123 + ".0"));
1190         assertFalse(NumberUtils.isParsable("0." + fullWidth123));
1191     }
1192 
1193     @Test
1194     void testIsParsableInfinity() {
1195         // sanity checks
1196         final String s = "Infinity";
1197         assertEquals(Double.POSITIVE_INFINITY, Double.parseDouble(s));
1198         assertEquals(Float.POSITIVE_INFINITY, Float.parseFloat(s));
1199         // isParsable
1200         assertTrue(NumberUtils.isParsable(s));
1201     }
1202 
1203     @Test
1204     void testIsParsableInfinityNegative() {
1205         // sanity checks
1206         final String s = "-Infinity";
1207         assertEquals(Double.NEGATIVE_INFINITY, Double.parseDouble(s));
1208         assertEquals(Float.NEGATIVE_INFINITY, Float.parseFloat(s));
1209         // isParsable
1210         assertTrue(NumberUtils.isParsable(s));
1211     }
1212 
1213     @Test
1214     void testIsParsableInfinityPositive() {
1215         // sanity checks
1216         final String s = "+Infinity";
1217         assertEquals(Double.POSITIVE_INFINITY, Double.parseDouble(s));
1218         assertEquals(Float.POSITIVE_INFINITY, Float.parseFloat(s));
1219         // isParsable
1220         assertTrue(NumberUtils.isParsable(s));
1221     }
1222 
1223     @Test
1224     void testIsParsableNaN() {
1225         // sanity checks
1226         final String s = "NaN";
1227         assertEquals(Double.NaN, Double.parseDouble(s));
1228         assertEquals(Float.NaN, Float.parseFloat(s));
1229         // isParsable
1230         assertTrue(NumberUtils.isParsable(s));
1231     }
1232 
1233     @Test
1234     void testIsParsableNull() {
1235         // Can't use null in @ValueSource(strings)
1236         assertFalse(NumberUtils.isParsable(null));
1237     }
1238 
1239     @ParameterizedTest
1240     // @formatter:off
1241     @ValueSource(strings = {
1242             "NaN",
1243             "Infinity",
1244             "-Infinity",
1245             "+Infinity",
1246             "64.",
1247             "-64.",
1248             "64.2",
1249             "64",
1250             "018",
1251             ".18",
1252             "-65",
1253             "-018",
1254             "-018.2",
1255             "-.236",
1256             "2.",
1257             "2.f",
1258             "2.d",
1259             "1.2e-5f",
1260             "1.2e-5d",
1261             // Additional tests for scientific notation.
1262             "1e5", "1E5", "1.2e5", "1.2E5", "1.2e+5", "1.2e-5", "-1.2e-5", "1e5f", "1e5F", "1e5d", "1e5D",
1263             // Additional tests for type suffixes.
1264             "2f", "2F", "2d", "2D", "2.0f", "2.0F", "2.0d", "2.0D", "-2.0f", "-2.0d" })
1265     // @formatter:on
1266     void testIsParsableTrue(final String input) {
1267         assertTrue(NumberUtils.isParsable(input));
1268     }
1269 
1270     @Test
1271     void testLang1087() {
1272         // no sign cases
1273         assertEquals(Float.class, NumberUtils.createNumber("0.0").getClass());
1274         assertEquals(Float.valueOf("0.0"), NumberUtils.createNumber("0.0"));
1275         // explicit positive sign cases
1276         assertEquals(Float.class, NumberUtils.createNumber("+0.0").getClass());
1277         assertEquals(Float.valueOf("+0.0"), NumberUtils.createNumber("+0.0"));
1278         // negative sign cases
1279         assertEquals(Float.class, NumberUtils.createNumber("-0.0").getClass());
1280         assertEquals(Float.valueOf("-0.0"), NumberUtils.createNumber("-0.0"));
1281     }
1282 
1283     @Test
1284     void testLANG1252() {
1285         compareIsCreatableWithCreateNumber("+2", true);
1286         compareIsCreatableWithCreateNumber("+2.0", true);
1287     }
1288 
1289     @Test
1290     void testLang1729IsParsableByte() {
1291         assertTrue(isParsableByte("1"));
1292         assertFalse(isParsableByte("1 2 3"));
1293         assertTrue(isParsableByte("123"));
1294         assertFalse(isParsableByte("1 2 3"));
1295     }
1296 
1297     @Test
1298     void testLang1729IsParsableDouble() {
1299         assertTrue(isParsableDouble("1"));
1300         assertTrue(isParsableDouble("1."));
1301         assertTrue(isParsableDouble("1.f"));
1302         assertTrue(isParsableDouble("1.d"));
1303         assertTrue(isParsableDouble("1.0"));
1304         assertFalse(isParsableDouble("1.0."));
1305         assertFalse(isParsableDouble("1 2 3"));
1306         assertFalse(isParsableDouble("1 2 3"));
1307     }
1308 
1309     @Test
1310     void testLang1729IsParsableFloat() {
1311         assertTrue(isParsableFloat("1"));
1312         assertTrue(isParsableFloat("1."));
1313         assertTrue(isParsableFloat("1.f"));
1314         assertTrue(isParsableFloat("1.d"));
1315         assertTrue(isParsableFloat("1.0"));
1316         assertFalse(isParsableFloat("1.0."));
1317         assertFalse(isParsableFloat("1 2 3"));
1318         assertFalse(isParsableFloat("1 2 3"));
1319     }
1320 
1321     @Test
1322     void testLang1729IsParsableInteger() {
1323         assertTrue(isParsableInteger("1"));
1324         assertFalse(isParsableInteger("1 2 3"));
1325         assertTrue(isParsableInteger("123"));
1326         assertFalse(isParsableInteger("1 2 3"));
1327     }
1328 
1329     @Test
1330     void testLang1729IsParsableLong() {
1331         assertTrue(isParsableLong("1"));
1332         assertFalse(isParsableLong("1 2 3"));
1333         assertTrue(isParsableLong("123"));
1334         assertFalse(isParsableLong("1 2 3"));
1335     }
1336 
1337     @Test
1338     void testLang1729IsParsableShort() {
1339         assertTrue(isParsableShort("1"));
1340         assertFalse(isParsableShort("1 2 3"));
1341         assertTrue(isParsableShort("123"));
1342         assertFalse(isParsableShort("1 2 3"));
1343     }
1344 
1345     /**
1346      * Tests <a href="https://issues.apache.org/jira/browse/LANG-1821">LANG-1821</a>.
1347      */
1348     @Test
1349     void testLang1821() {
1350         compareIsCreatableWithCreateNumber("123L", true);
1351         compareIsCreatableWithCreateNumber("0xdef", true);
1352         compareIsCreatableWithCreateNumber("0xdefL", true);
1353         compareIsCreatableWithCreateNumber("0XDEFl", true);
1354         // Integer.MAX_VALUE
1355         compareIsCreatableWithCreateNumber("0x" + Integer.toHexString(Integer.MAX_VALUE), true);
1356         compareIsCreatableWithCreateNumber("0x" + Integer.toHexString(Integer.MAX_VALUE) + "l", true);
1357         compareIsCreatableWithCreateNumber("0x" + Integer.toHexString(Integer.MAX_VALUE) + "L", true);
1358         compareIsCreatableWithCreateNumber("0X" + Integer.toHexString(Integer.MAX_VALUE), true);
1359         compareIsCreatableWithCreateNumber("0X" + Integer.toHexString(Integer.MAX_VALUE) + "l", true);
1360         compareIsCreatableWithCreateNumber("0X" + Integer.toHexString(Integer.MAX_VALUE) + "L", true);
1361         // Long.MAX_VALUE
1362         compareIsCreatableWithCreateNumber("0x" + Long.toHexString(Long.MAX_VALUE), true);
1363         compareIsCreatableWithCreateNumber("0x" + Long.toHexString(Long.MAX_VALUE) + "l", true);
1364         compareIsCreatableWithCreateNumber("0x" + Long.toHexString(Long.MAX_VALUE) + "L", true);
1365         compareIsCreatableWithCreateNumber("0X" + Long.toHexString(Long.MAX_VALUE), true);
1366         compareIsCreatableWithCreateNumber("0X" + Long.toHexString(Long.MAX_VALUE) + "l", true);
1367         compareIsCreatableWithCreateNumber("0X" + Long.toHexString(Long.MAX_VALUE) + "L", true);
1368     }
1369 
1370     @Test
1371     void testLang300() {
1372         NumberUtils.createNumber("-1l");
1373         NumberUtils.createNumber("01l");
1374         NumberUtils.createNumber("1l");
1375     }
1376 
1377     @Test
1378     void testLang381() {
1379         assertTrue(Double.isNaN(NumberUtils.min(1.2, 2.5, Double.NaN)));
1380         assertTrue(Double.isNaN(NumberUtils.max(1.2, 2.5, Double.NaN)));
1381         assertTrue(Float.isNaN(NumberUtils.min(1.2f, 2.5f, Float.NaN)));
1382         assertTrue(Float.isNaN(NumberUtils.max(1.2f, 2.5f, Float.NaN)));
1383         final double[] a = { 1.2, Double.NaN, 3.7, 27.0, 42.0, Double.NaN };
1384         assertTrue(Double.isNaN(NumberUtils.max(a)));
1385         assertTrue(Double.isNaN(NumberUtils.min(a)));
1386         final double[] b = { Double.NaN, 1.2, Double.NaN, 3.7, 27.0, 42.0, Double.NaN };
1387         assertTrue(Double.isNaN(NumberUtils.max(b)));
1388         assertTrue(Double.isNaN(NumberUtils.min(b)));
1389         final float[] aF = { 1.2f, Float.NaN, 3.7f, 27.0f, 42.0f, Float.NaN };
1390         assertTrue(Float.isNaN(NumberUtils.max(aF)));
1391         final float[] bF = { Float.NaN, 1.2f, Float.NaN, 3.7f, 27.0f, 42.0f, Float.NaN };
1392         assertTrue(Float.isNaN(NumberUtils.max(bF)));
1393     }
1394 
1395     @Test
1396     void testLang747() {
1397         assertEquals(Integer.valueOf(0x8000), NumberUtils.createNumber("0x8000"));
1398         assertEquals(Integer.valueOf(0x80000), NumberUtils.createNumber("0x80000"));
1399         assertEquals(Integer.valueOf(0x800000), NumberUtils.createNumber("0x800000"));
1400         assertEquals(Integer.valueOf(0x8000000), NumberUtils.createNumber("0x8000000"));
1401         assertEquals(Integer.valueOf(0x7FFFFFFF), NumberUtils.createNumber("0x7FFFFFFF"));
1402         assertEquals(Long.valueOf(0x80000000L), NumberUtils.createNumber("0x80000000"));
1403         assertEquals(Long.valueOf(0xFFFFFFFFL), NumberUtils.createNumber("0xFFFFFFFF"));
1404         // Leading zero tests
1405         assertEquals(Integer.valueOf(0x8000000), NumberUtils.createNumber("0x08000000"));
1406         assertEquals(Integer.valueOf(0x7FFFFFFF), NumberUtils.createNumber("0x007FFFFFFF"));
1407         assertEquals(Long.valueOf(0x80000000L), NumberUtils.createNumber("0x080000000"));
1408         assertEquals(Long.valueOf(0xFFFFFFFFL), NumberUtils.createNumber("0x00FFFFFFFF"));
1409         assertEquals(Long.valueOf(0x800000000L), NumberUtils.createNumber("0x800000000"));
1410         assertEquals(Long.valueOf(0x8000000000L), NumberUtils.createNumber("0x8000000000"));
1411         assertEquals(Long.valueOf(0x80000000000L), NumberUtils.createNumber("0x80000000000"));
1412         assertEquals(Long.valueOf(0x800000000000L), NumberUtils.createNumber("0x800000000000"));
1413         assertEquals(Long.valueOf(0x8000000000000L), NumberUtils.createNumber("0x8000000000000"));
1414         assertEquals(Long.valueOf(0x80000000000000L), NumberUtils.createNumber("0x80000000000000"));
1415         assertEquals(Long.valueOf(0x800000000000000L), NumberUtils.createNumber("0x800000000000000"));
1416         assertEquals(Long.valueOf(0x7FFFFFFFFFFFFFFFL), NumberUtils.createNumber("0x7FFFFFFFFFFFFFFF"));
1417         // Cannot use a hex constant such as 0x8000000000000000L here as that is interpreted as a negative long
1418         assertEquals(new BigInteger("8000000000000000", 16), NumberUtils.createNumber("0x8000000000000000"));
1419         assertEquals(new BigInteger("FFFFFFFFFFFFFFFF", 16), NumberUtils.createNumber("0xFFFFFFFFFFFFFFFF"));
1420         // Leading zero tests
1421         assertEquals(Long.valueOf(0x80000000000000L), NumberUtils.createNumber("0x00080000000000000"));
1422         assertEquals(Long.valueOf(0x800000000000000L), NumberUtils.createNumber("0x0800000000000000"));
1423         assertEquals(Long.valueOf(0x7FFFFFFFFFFFFFFFL), NumberUtils.createNumber("0x07FFFFFFFFFFFFFFF"));
1424         // Cannot use a hex constant such as 0x8000000000000000L here as that is interpreted as a negative long
1425         assertEquals(new BigInteger("8000000000000000", 16), NumberUtils.createNumber("0x00008000000000000000"));
1426         assertEquals(new BigInteger("FFFFFFFFFFFFFFFF", 16), NumberUtils.createNumber("0x0FFFFFFFFFFFFFFFF"));
1427     }
1428 
1429     @Test
1430     void testLANG971() {
1431         compareIsCreatableWithCreateNumber("0085", false);
1432         compareIsCreatableWithCreateNumber("085", false);
1433         compareIsCreatableWithCreateNumber("08", false);
1434         compareIsCreatableWithCreateNumber("07", true);
1435         compareIsCreatableWithCreateNumber("00", true);
1436     }
1437 
1438     @Test
1439     void testLANG972() {
1440         compareIsCreatableWithCreateNumber("0xABCD", true);
1441         compareIsCreatableWithCreateNumber("0XABCD", true);
1442     }
1443 
1444     @Test
1445     void testLANG992() {
1446         compareIsCreatableWithCreateNumber("0.0", true);
1447         compareIsCreatableWithCreateNumber("0.4790", true);
1448     }
1449 
1450     @Test
1451     void testMaxByte() {
1452         assertEquals((byte) 5, NumberUtils.max((byte) 5), "max(byte[]) failed for array length 1");
1453         assertEquals((byte) 9, NumberUtils.max((byte) 6, (byte) 9), "max(byte[]) failed for array length 2");
1454         assertEquals((byte) 10, NumberUtils.max((byte) -10, (byte) -5, (byte) 0, (byte) 5, (byte) 10), "max(byte[]) failed for array length 5");
1455         assertEquals((byte) 10, NumberUtils.max((byte) -10, (byte) -5, (byte) 0, (byte) 5, (byte) 10));
1456         assertEquals((byte) 10, NumberUtils.max((byte) -5, (byte) 0, (byte) 10, (byte) 5, (byte) -10));
1457     }
1458 
1459     @Test
1460     void testMaxByte_emptyArray() {
1461         assertIllegalArgumentException(NumberUtils::max);
1462     }
1463 
1464     @Test
1465     void testMaxByte_nullArray() {
1466         assertNullPointerException(() -> NumberUtils.max((byte[]) null));
1467     }
1468 
1469     @Test
1470     void testMaxDouble() {
1471         assertEquals(5.1d, NumberUtils.max(5.1d), "max(double[]) failed for array length 1");
1472         assertEquals(9.2d, NumberUtils.max(6.3d, 9.2d), "max(double[]) failed for array length 2");
1473         assertEquals(10.4d, NumberUtils.max(-10.5d, -5.6d, 0, 5.7d, 10.4d), "max(double[]) failed for double length 5");
1474         assertEquals(10d, NumberUtils.max(-10d, -5d, 0d, 5d, 10d));
1475         assertEquals(10d, NumberUtils.max(-5d, 0d, 10d, 5d, -10d));
1476     }
1477 
1478     @Test
1479     void testMaxDouble_emptyArray() {
1480         assertIllegalArgumentException(NumberUtils::max);
1481     }
1482 
1483     @Test
1484     void testMaxDouble_nullArray() {
1485         assertNullPointerException(() -> NumberUtils.max((double[]) null));
1486     }
1487 
1488     @Test
1489     void testMaxFloat() {
1490         assertEquals(5.1f, NumberUtils.max(5.1f), "max(float[]) failed for array length 1");
1491         assertEquals(9.2f, NumberUtils.max(6.3f, 9.2f), "max(float[]) failed for array length 2");
1492         assertEquals(10.4f, NumberUtils.max(-10.5f, -5.6f, 0, 5.7f, 10.4f), "max(float[]) failed for float length 5");
1493         assertEquals(10f, NumberUtils.max(-10f, -5f, 0f, 5f, 10f), 0.0001f);
1494         assertEquals(10f, NumberUtils.max(-5f, 0f, 10f, 5f, -10f), 0.0001f);
1495     }
1496 
1497     @Test
1498     void testMaxFloat_emptyArray() {
1499         assertIllegalArgumentException(NumberUtils::max);
1500     }
1501 
1502     @Test
1503     void testMaxFloat_nullArray() {
1504         assertNullPointerException(() -> NumberUtils.max((float[]) null));
1505     }
1506 
1507     @Test
1508     void testMaximumByte() {
1509         final byte low = 123;
1510         final byte mid = 123 + 1;
1511         final byte high = 123 + 2;
1512         assertEquals(high, NumberUtils.max(low, mid, high), "maximum(byte, byte, byte) 1 failed");
1513         assertEquals(high, NumberUtils.max(mid, low, high), "maximum(byte, byte, byte) 2 failed");
1514         assertEquals(high, NumberUtils.max(mid, high, low), "maximum(byte, byte, byte) 3 failed");
1515         assertEquals(high, NumberUtils.max(high, mid, high), "maximum(byte, byte, byte) 4 failed");
1516     }
1517 
1518     @Test
1519     void testMaximumDouble() {
1520         final double low = 12.3;
1521         final double mid = 12.3 + 1;
1522         final double high = 12.3 + 2;
1523         assertEquals(high, NumberUtils.max(low, mid, high), 0.0001);
1524         assertEquals(high, NumberUtils.max(mid, low, high), 0.0001);
1525         assertEquals(high, NumberUtils.max(mid, high, low), 0.0001);
1526         assertEquals(mid, NumberUtils.max(low, mid, low), 0.0001);
1527         assertEquals(high, NumberUtils.max(high, mid, high), 0.0001);
1528     }
1529 
1530     @Test
1531     void testMaximumFloat() {
1532         final float low = 12.3f;
1533         final float mid = 12.3f + 1;
1534         final float high = 12.3f + 2;
1535         assertEquals(high, NumberUtils.max(low, mid, high), 0.0001f);
1536         assertEquals(high, NumberUtils.max(mid, low, high), 0.0001f);
1537         assertEquals(high, NumberUtils.max(mid, high, low), 0.0001f);
1538         assertEquals(mid, NumberUtils.max(low, mid, low), 0.0001f);
1539         assertEquals(high, NumberUtils.max(high, mid, high), 0.0001f);
1540     }
1541 
1542     @Test
1543     void testMaximumInt() {
1544         assertEquals(12345, NumberUtils.max(12345, 12345 - 1, 12345 - 2), "maximum(int, int, int) 1 failed");
1545         assertEquals(12345, NumberUtils.max(12345 - 1, 12345, 12345 - 2), "maximum(int, int, int) 2 failed");
1546         assertEquals(12345, NumberUtils.max(12345 - 1, 12345 - 2, 12345), "maximum(int, int, int) 3 failed");
1547         assertEquals(12345, NumberUtils.max(12345 - 1, 12345, 12345), "maximum(int, int, int) 4 failed");
1548         assertEquals(12345, NumberUtils.max(12345, 12345, 12345), "maximum(int, int, int) 5 failed");
1549     }
1550 
1551     @Test
1552     void testMaximumLong() {
1553         assertEquals(12345L, NumberUtils.max(12345L, 12345L - 1L, 12345L - 2L), "maximum(long, long, long) 1 failed");
1554         assertEquals(12345L, NumberUtils.max(12345L - 1L, 12345L, 12345L - 2L), "maximum(long, long, long) 2 failed");
1555         assertEquals(12345L, NumberUtils.max(12345L - 1L, 12345L - 2L, 12345L), "maximum(long, long, long) 3 failed");
1556         assertEquals(12345L, NumberUtils.max(12345L - 1L, 12345L, 12345L), "maximum(long, long, long) 4 failed");
1557         assertEquals(12345L, NumberUtils.max(12345L, 12345L, 12345L), "maximum(long, long, long) 5 failed");
1558     }
1559 
1560     @Test
1561     void testMaximumShort() {
1562         final short low = 1234;
1563         final short mid = 1234 + 1;
1564         final short high = 1234 + 2;
1565         assertEquals(high, NumberUtils.max(low, mid, high), "maximum(short, short, short) 1 failed");
1566         assertEquals(high, NumberUtils.max(mid, low, high), "maximum(short, short, short) 2 failed");
1567         assertEquals(high, NumberUtils.max(mid, high, low), "maximum(short, short, short) 3 failed");
1568         assertEquals(high, NumberUtils.max(high, mid, high), "maximum(short, short, short) 4 failed");
1569     }
1570 
1571     @Test
1572     void testMaxInt() {
1573         assertEquals(5, NumberUtils.max(5), "max(int[]) failed for array length 1");
1574         assertEquals(9, NumberUtils.max(6, 9), "max(int[]) failed for array length 2");
1575         assertEquals(10, NumberUtils.max(-10, -5, 0, 5, 10), "max(int[]) failed for array length 5");
1576         assertEquals(10, NumberUtils.max(-10, -5, 0, 5, 10));
1577         assertEquals(10, NumberUtils.max(-5, 0, 10, 5, -10));
1578     }
1579 
1580     @Test
1581     void testMaxInt_emptyArray() {
1582         assertIllegalArgumentException(NumberUtils::max);
1583     }
1584 
1585     @Test
1586     void testMaxInt_nullArray() {
1587         assertNullPointerException(() -> NumberUtils.max((int[]) null));
1588     }
1589 
1590     @Test
1591     void testMaxLong() {
1592         assertEquals(5L, NumberUtils.max(5L), "max(long[]) failed for array length 1");
1593         assertEquals(9L, NumberUtils.max(6L, 9L), "max(long[]) failed for array length 2");
1594         assertEquals(10L, NumberUtils.max(-10L, -5L, 0L, 5L, 10L), "max(long[]) failed for array length 5");
1595         assertEquals(10L, NumberUtils.max(-10L, -5L, 0L, 5L, 10L));
1596         assertEquals(10L, NumberUtils.max(-5L, 0L, 10L, 5L, -10L));
1597     }
1598 
1599     @Test
1600     void testMaxLong_emptyArray() {
1601         assertIllegalArgumentException(NumberUtils::max);
1602     }
1603 
1604     @Test
1605     void testMaxLong_nullArray() {
1606         assertNullPointerException(() -> NumberUtils.max((long[]) null));
1607     }
1608 
1609     @Test
1610     void testMaxShort() {
1611         assertEquals((short) 5, NumberUtils.max((short) 5), "max(short[]) failed for array length 1");
1612         assertEquals((short) 9, NumberUtils.max((short) 6, (short) 9), "max(short[]) failed for array length 2");
1613         assertEquals((short) 10, NumberUtils.max((short) -10, (short) -5, (short) 0, (short) 5, (short) 10), "max(short[]) failed for array length 5");
1614         assertEquals((short) 10, NumberUtils.max((short) -10, (short) -5, (short) 0, (short) 5, (short) 10));
1615         assertEquals((short) 10, NumberUtils.max((short) -5, (short) 0, (short) 10, (short) 5, (short) -10));
1616     }
1617 
1618     @Test
1619     void testMaxShort_emptyArray() {
1620         assertIllegalArgumentException(NumberUtils::max);
1621     }
1622 
1623     @Test
1624     void testMaxShort_nullArray() {
1625         assertNullPointerException(() -> NumberUtils.max((short[]) null));
1626     }
1627 
1628     @Test
1629     void testMinByte() {
1630         assertEquals((byte) 5, NumberUtils.min((byte) 5), "min(byte[]) failed for array length 1");
1631         assertEquals((byte) 6, NumberUtils.min((byte) 6, (byte) 9), "min(byte[]) failed for array length 2");
1632         assertEquals((byte) -10, NumberUtils.min((byte) -10, (byte) -5, (byte) 0, (byte) 5, (byte) 10));
1633         assertEquals((byte) -10, NumberUtils.min((byte) -5, (byte) 0, (byte) -10, (byte) 5, (byte) 10));
1634     }
1635 
1636     @Test
1637     void testMinByte_emptyArray() {
1638         assertIllegalArgumentException(NumberUtils::min);
1639     }
1640 
1641     @Test
1642     void testMinByte_nullArray() {
1643         assertNullPointerException(() -> NumberUtils.min((byte[]) null));
1644     }
1645 
1646     @Test
1647     void testMinDouble() {
1648         assertEquals(5.12, NumberUtils.min(5.12), "min(double[]) failed for array length 1");
1649         assertEquals(6.23, NumberUtils.min(6.23, 9.34), "min(double[]) failed for array length 2");
1650         assertEquals(-10.45, NumberUtils.min(-10.45, -5.56, 0, 5.67, 10.78), "min(double[]) failed for array length 5");
1651         assertEquals(-10, NumberUtils.min(-10, -5, 0, 5, 10), 0.0001);
1652         assertEquals(-10, NumberUtils.min(-5, 0, -10, 5, 10), 0.0001);
1653         assertEquals(5.12, NumberUtils.min(6.11, 5.12));
1654     }
1655 
1656     @Test
1657     void testMinDouble_emptyArray() {
1658         assertIllegalArgumentException(NumberUtils::min);
1659     }
1660 
1661     @Test
1662     void testMinDouble_nullArray() {
1663         assertNullPointerException(() -> NumberUtils.min((double[]) null));
1664     }
1665 
1666     @Test
1667     void testMinFloat() {
1668         assertEquals(5.9f, NumberUtils.min(5.9f), "min(float[]) failed for array length 1");
1669         assertEquals(6.8f, NumberUtils.min(6.8f, 9.7f), "min(float[]) failed for array length 2");
1670         assertEquals(-10.6f, NumberUtils.min(-10.6f, -5.5f, 0, 5.4f, 10.3f), "min(float[]) failed for array length 5");
1671         assertEquals(-10, NumberUtils.min(-10, -5, 0, 5, 10), 0.0001f);
1672         assertEquals(-10, NumberUtils.min(-5, 0, -10, 5, 10), 0.0001f);
1673         assertEquals(Float.NaN, NumberUtils.min(6.8f, Float.NaN));
1674         assertEquals(3.7f, NumberUtils.min(6.8f, 3.7f));
1675     }
1676 
1677     @Test
1678     void testMinFloat_emptyArray() {
1679         assertIllegalArgumentException(NumberUtils::min);
1680     }
1681 
1682     @Test
1683     void testMinFloat_nullArray() {
1684         assertNullPointerException(() -> NumberUtils.min((float[]) null));
1685     }
1686 
1687     @Test
1688     void testMinimumByte() {
1689         final byte low = 123;
1690         final byte mid = 123 + 1;
1691         final byte high = 123 + 2;
1692         assertEquals(low, NumberUtils.min(low, mid, high), "minimum(byte, byte, byte) 1 failed");
1693         assertEquals(low, NumberUtils.min(mid, low, high), "minimum(byte, byte, byte) 2 failed");
1694         assertEquals(low, NumberUtils.min(mid, high, low), "minimum(byte, byte, byte) 3 failed");
1695         assertEquals(low, NumberUtils.min(low, mid, low), "minimum(byte, byte, byte) 4 failed");
1696     }
1697 
1698     @Test
1699     void testMinimumDouble() {
1700         final double low = 12.3;
1701         final double mid = 12.3 + 1;
1702         final double high = 12.3 + 2;
1703         assertEquals(low, NumberUtils.min(low, mid, high), 0.0001);
1704         assertEquals(low, NumberUtils.min(mid, low, high), 0.0001);
1705         assertEquals(low, NumberUtils.min(mid, high, low), 0.0001);
1706         assertEquals(low, NumberUtils.min(low, mid, low), 0.0001);
1707         assertEquals(mid, NumberUtils.min(high, mid, high), 0.0001);
1708     }
1709 
1710     @Test
1711     void testMinimumFloat() {
1712         final float low = 12.3f;
1713         final float mid = 12.3f + 1;
1714         final float high = 12.3f + 2;
1715         assertEquals(low, NumberUtils.min(low, mid, high), 0.0001f);
1716         assertEquals(low, NumberUtils.min(mid, low, high), 0.0001f);
1717         assertEquals(low, NumberUtils.min(mid, high, low), 0.0001f);
1718         assertEquals(low, NumberUtils.min(low, mid, low), 0.0001f);
1719         assertEquals(mid, NumberUtils.min(high, mid, high), 0.0001f);
1720     }
1721 
1722     @Test
1723     void testMinimumInt() {
1724         assertEquals(12345, NumberUtils.min(12345, 12345 + 1, 12345 + 2), "minimum(int, int, int) 1 failed");
1725         assertEquals(12345, NumberUtils.min(12345 + 1, 12345, 12345 + 2), "minimum(int, int, int) 2 failed");
1726         assertEquals(12345, NumberUtils.min(12345 + 1, 12345 + 2, 12345), "minimum(int, int, int) 3 failed");
1727         assertEquals(12345, NumberUtils.min(12345 + 1, 12345, 12345), "minimum(int, int, int) 4 failed");
1728         assertEquals(12345, NumberUtils.min(12345, 12345, 12345), "minimum(int, int, int) 5 failed");
1729     }
1730 
1731     @Test
1732     void testMinimumLong() {
1733         assertEquals(12345L, NumberUtils.min(12345L, 12345L + 1L, 12345L + 2L), "minimum(long, long, long) 1 failed");
1734         assertEquals(12345L, NumberUtils.min(12345L + 1L, 12345L, 12345 + 2L), "minimum(long, long, long) 2 failed");
1735         assertEquals(12345L, NumberUtils.min(12345L + 1L, 12345L + 2L, 12345L), "minimum(long, long, long) 3 failed");
1736         assertEquals(12345L, NumberUtils.min(12345L + 1L, 12345L, 12345L), "minimum(long, long, long) 4 failed");
1737         assertEquals(12345L, NumberUtils.min(12345L, 12345L, 12345L), "minimum(long, long, long) 5 failed");
1738     }
1739 
1740     @Test
1741     void testMinimumShort() {
1742         final short low = 1234;
1743         final short mid = 1234 + 1;
1744         final short high = 1234 + 2;
1745         assertEquals(low, NumberUtils.min(low, mid, high), "minimum(short, short, short) 1 failed");
1746         assertEquals(low, NumberUtils.min(mid, low, high), "minimum(short, short, short) 2 failed");
1747         assertEquals(low, NumberUtils.min(mid, high, low), "minimum(short, short, short) 3 failed");
1748         assertEquals(low, NumberUtils.min(low, mid, low), "minimum(short, short, short) 4 failed");
1749     }
1750 
1751     @Test
1752     void testMinInt() {
1753         assertEquals(5, NumberUtils.min(5), "min(int[]) failed for array length 1");
1754         assertEquals(6, NumberUtils.min(6, 9), "min(int[]) failed for array length 2");
1755         assertEquals(-10, NumberUtils.min(-10, -5, 0, 5, 10));
1756         assertEquals(-10, NumberUtils.min(-5, 0, -10, 5, 10));
1757     }
1758 
1759     @Test
1760     void testMinInt_emptyArray() {
1761         assertIllegalArgumentException(NumberUtils::min);
1762     }
1763 
1764     @Test
1765     void testMinInt_nullArray() {
1766         assertNullPointerException(() -> NumberUtils.min((int[]) null));
1767     }
1768 
1769     @Test
1770     void testMinLong() {
1771         assertEquals(5L, NumberUtils.min(5L), "min(long[]) failed for array length 1");
1772         assertEquals(6L, NumberUtils.min(6L, 9L), "min(long[]) failed for array length 2");
1773         assertEquals(-10L, NumberUtils.min(-10L, -5L, 0L, 5L, 10L));
1774         assertEquals(-10L, NumberUtils.min(-5L, 0L, -10L, 5L, 10L));
1775     }
1776 
1777     @Test
1778     void testMinLong_emptyArray() {
1779         assertIllegalArgumentException(NumberUtils::min);
1780     }
1781 
1782     @Test
1783     void testMinLong_nullArray() {
1784         assertNullPointerException(() -> NumberUtils.min((long[]) null));
1785     }
1786 
1787     @Test
1788     void testMinMaxSignedZero() {
1789         // The varargs overloads must agree with Math.min/Math.max (and the three-argument
1790         // overloads, which delegate to them) on the sign of zero. -0.0 is distinct from 0.0,
1791         // e.g. 1 / -0.0 is -Infinity, so the raw bits are asserted here.
1792         assertEquals(Double.doubleToRawLongBits(0.0d), Double.doubleToRawLongBits(NumberUtils.max(-0.0d, 0.0d)));
1793         assertEquals(Double.doubleToRawLongBits(0.0d), Double.doubleToRawLongBits(NumberUtils.max(0.0d, -0.0d)));
1794         assertEquals(Double.doubleToRawLongBits(-0.0d), Double.doubleToRawLongBits(NumberUtils.min(-0.0d, 0.0d)));
1795         assertEquals(Double.doubleToRawLongBits(-0.0d), Double.doubleToRawLongBits(NumberUtils.min(0.0d, -0.0d)));
1796         assertEquals(Float.floatToRawIntBits(0.0f), Float.floatToRawIntBits(NumberUtils.max(-0.0f, 0.0f)));
1797         assertEquals(Float.floatToRawIntBits(0.0f), Float.floatToRawIntBits(NumberUtils.max(0.0f, -0.0f)));
1798         assertEquals(Float.floatToRawIntBits(-0.0f), Float.floatToRawIntBits(NumberUtils.min(-0.0f, 0.0f)));
1799         assertEquals(Float.floatToRawIntBits(-0.0f), Float.floatToRawIntBits(NumberUtils.min(0.0f, -0.0f)));
1800         // the varargs result matches the three-argument overload
1801         assertEquals(Double.doubleToRawLongBits(NumberUtils.max(-0.0d, 0.0d, 0.0d)), Double.doubleToRawLongBits(NumberUtils.max(-0.0d, 0.0d)));
1802         assertEquals(Double.doubleToRawLongBits(NumberUtils.min(0.0d, -0.0d, 0.0d)), Double.doubleToRawLongBits(NumberUtils.min(0.0d, -0.0d)));
1803     }
1804 
1805     @Test
1806     void testMinShort() {
1807         assertEquals((short) 5, NumberUtils.min((short) 5), "min(short[]) failed for array length 1");
1808         assertEquals((short) 6, NumberUtils.min((short) 6, (short) 9), "min(short[]) failed for array length 2");
1809         assertEquals((short) -10, NumberUtils.min((short) -10, (short) -5, (short) 0, (short) 5, (short) 10));
1810         assertEquals((short) -10, NumberUtils.min((short) -5, (short) 0, (short) -10, (short) 5, (short) 10));
1811     }
1812 
1813     @Test
1814     void testMinShort_emptyArray() {
1815         assertIllegalArgumentException(NumberUtils::min);
1816     }
1817 
1818     @Test
1819     void testMinShort_nullArray() {
1820         assertNullPointerException(() -> NumberUtils.min((short[]) null));
1821     }
1822 
1823     /**
1824      * Test for {@link NumberUtils#createNumber(String)}
1825      */
1826     @Test
1827     void testStringCreateNumberEnsureNoPrecisionLoss() {
1828         assertInstanceOf(Float.class, NumberUtils.createNumber("1.23"));
1829         assertInstanceOf(Double.class, NumberUtils.createNumber("3.40282354e+38"));
1830         assertInstanceOf(BigDecimal.class, NumberUtils.createNumber("1.797693134862315759e+308"));
1831         // LANG-1060
1832         assertInstanceOf(Float.class, NumberUtils.createNumber("001.12"));
1833         assertInstanceOf(Float.class, NumberUtils.createNumber("-001.12"));
1834         assertInstanceOf(Float.class, NumberUtils.createNumber("+001.12"));
1835         assertInstanceOf(Double.class, NumberUtils.createNumber("003.40282354e+38"));
1836         assertInstanceOf(Double.class, NumberUtils.createNumber("-003.40282354e+38"));
1837         assertInstanceOf(Double.class, NumberUtils.createNumber("+003.40282354e+38"));
1838         assertInstanceOf(BigDecimal.class, NumberUtils.createNumber("0001.797693134862315759e+308"));
1839         assertInstanceOf(BigDecimal.class, NumberUtils.createNumber("-001.797693134862315759e+308"));
1840         assertInstanceOf(BigDecimal.class, NumberUtils.createNumber("+001.797693134862315759e+308"));
1841         // LANG-1613
1842         assertInstanceOf(Double.class, NumberUtils.createNumber("2.2250738585072014E-308"));
1843         assertInstanceOf(Double.class, NumberUtils.createNumber("2.2250738585072014E-308D"));
1844         assertInstanceOf(Double.class, NumberUtils.createNumber("2.2250738585072014E-308F"));
1845         assertInstanceOf(Double.class, NumberUtils.createNumber("4.9E-324"));
1846         assertInstanceOf(Double.class, NumberUtils.createNumber("4.9E-324D"));
1847         assertInstanceOf(Double.class, NumberUtils.createNumber("4.9E-324F"));
1848         assertInstanceOf(Double.class, NumberUtils.createNumber("1.7976931348623157E308"));
1849         assertInstanceOf(Double.class, NumberUtils.createNumber("1.7976931348623157E308D"));
1850         assertInstanceOf(Double.class, NumberUtils.createNumber("1.7976931348623157E308F"));
1851         assertInstanceOf(Double.class, NumberUtils.createNumber("4.9e-324D"));
1852         assertInstanceOf(Double.class, NumberUtils.createNumber("4.9e-324F"));
1853         // LANG-1444
1854         assertInstanceOf(Float.class, NumberUtils.createNumber("1.1"));
1855         assertInstanceOf(Float.class, NumberUtils.createNumber("1.01"));
1856         assertInstanceOf(Float.class, NumberUtils.createNumber("1.001"));
1857         assertInstanceOf(Float.class, NumberUtils.createNumber("1.0001"));
1858         assertInstanceOf(Float.class, NumberUtils.createNumber("1.00001"));
1859         assertInstanceOf(Float.class, NumberUtils.createNumber("1.000001"));
1860         assertInstanceOf(Float.class, NumberUtils.createNumber("1.0000001"));
1861         assertInstanceOf(Double.class, NumberUtils.createNumber("1.00000001"));
1862         assertInstanceOf(Double.class, NumberUtils.createNumber("1.000000001"));
1863         assertInstanceOf(Double.class, NumberUtils.createNumber("1.0000000001"));
1864         assertInstanceOf(Double.class, NumberUtils.createNumber("1.00000000001"));
1865         assertInstanceOf(Double.class, NumberUtils.createNumber("1.000000000001"));
1866         assertInstanceOf(Double.class, NumberUtils.createNumber("1.0000000000001"));
1867         assertInstanceOf(Double.class, NumberUtils.createNumber("1.00000000000001"));
1868         assertInstanceOf(Double.class, NumberUtils.createNumber("1.000000000000001"));
1869         // Now we get Floats: This happens because Double.valueOf("1.000000000000001") = 1.000000000000001 and Double.valueOf("1.0000000000000001") = 1.0. In
1870         // the latter case because we've lost the precision, it no longer matters whether we store the number as a Double or a Float, so we use a Float because
1871         // it's been truncated.
1872         assertInstanceOf(Float.class, NumberUtils.createNumber("1.0000000000000001"));
1873         assertInstanceOf(Float.class, NumberUtils.createNumber("1.00000000000000001"));
1874         assertInstanceOf(Float.class, NumberUtils.createNumber("1.000000000000000001"));
1875         assertInstanceOf(Float.class, NumberUtils.createNumber("1.0000000000000000001"));
1876         assertInstanceOf(Float.class, NumberUtils.createNumber("1.00000000000000000001"));
1877         assertInstanceOf(Float.class, NumberUtils.createNumber("1.000000000000000000001"));
1878         assertInstanceOf(Float.class, NumberUtils.createNumber("1.0000000000000000000001"));
1879         assertInstanceOf(Float.class, NumberUtils.createNumber("1.00000000000000000000001"));
1880     }
1881 
1882     /**
1883      * Test for {@link NumberUtils#toDouble(String)}.
1884      */
1885     @Test
1886     void testStringToDoubleString() {
1887         assertEquals(NumberUtils.toDouble("-1.2345"), -1.2345d, "toDouble(String) 1 failed");
1888         assertEquals(1.2345d, NumberUtils.toDouble("1.2345"), "toDouble(String) 2 failed");
1889         assertEquals(0.0d, NumberUtils.toDouble("abc"), "toDouble(String) 3 failed");
1890         // LANG-1060
1891         assertEquals(NumberUtils.toDouble("-001.2345"), -1.2345d, "toDouble(String) 4 failed");
1892         assertEquals(1.2345d, NumberUtils.toDouble("+001.2345"), "toDouble(String) 5 failed");
1893         assertEquals(1.2345d, NumberUtils.toDouble("001.2345"), "toDouble(String) 6 failed");
1894         assertEquals(0d, NumberUtils.toDouble("000.00000"), "toDouble(String) 7 failed");
1895         assertEquals(NumberUtils.toDouble(Double.MAX_VALUE + ""), Double.MAX_VALUE, "toDouble(Double.MAX_VALUE) failed");
1896         assertEquals(NumberUtils.toDouble(Double.MIN_VALUE + ""), Double.MIN_VALUE, "toDouble(Double.MIN_VALUE) failed");
1897         assertEquals(0.0d, NumberUtils.toDouble(""), "toDouble(empty) failed");
1898         assertEquals(0.0d, NumberUtils.toDouble((String) null), "toDouble(null) failed");
1899     }
1900 
1901     /**
1902      * Test for {@link NumberUtils#toDouble(String, double)}.
1903      */
1904     @Test
1905     void testStringToDoubleStringD() {
1906         assertEquals(1.2345d, NumberUtils.toDouble("1.2345", 5.1d), "toDouble(String, int) 1 failed");
1907         assertEquals(5.0d, NumberUtils.toDouble("a", 5.0d), "toDouble(String, int) 2 failed");
1908         // LANG-1060
1909         assertEquals(1.2345d, NumberUtils.toDouble("001.2345", 5.1d), "toDouble(String, int) 3 failed");
1910         assertEquals(NumberUtils.toDouble("-001.2345", 5.1d), -1.2345d, "toDouble(String, int) 4 failed");
1911         assertEquals(1.2345d, NumberUtils.toDouble("+001.2345", 5.1d), "toDouble(String, int) 5 failed");
1912         assertEquals(0d, NumberUtils.toDouble("000.00", 5.1d), "toDouble(String, int) 7 failed");
1913         assertEquals(5.1d, NumberUtils.toDouble("", 5.1d));
1914         assertEquals(5.1d, NumberUtils.toDouble((String) null, 5.1d));
1915     }
1916 
1917     /**
1918      * Test for {@link NumberUtils#toByte(String)}.
1919      */
1920     @Test
1921     void testToByteString() {
1922         assertEquals(123, NumberUtils.toByte("123"), "toByte(String) 1 failed");
1923         assertEquals(0, NumberUtils.toByte("abc"), "toByte(String) 2 failed");
1924         assertEquals(0, NumberUtils.toByte(""), "toByte(empty) failed");
1925         assertEquals(0, NumberUtils.toByte(null), "toByte(null) failed");
1926     }
1927 
1928     /**
1929      * Test for {@link NumberUtils#toByte(String, byte)}.
1930      */
1931     @Test
1932     void testToByteStringI() {
1933         assertEquals(123, NumberUtils.toByte("123", (byte) 5), "toByte(String, byte) 1 failed");
1934         assertEquals(5, NumberUtils.toByte("12.3", (byte) 5), "toByte(String, byte) 2 failed");
1935         assertEquals(5, NumberUtils.toByte("", (byte) 5));
1936         assertEquals(5, NumberUtils.toByte(null, (byte) 5));
1937     }
1938 
1939     /**
1940      * Test for {@link NumberUtils#toFloat(String)}.
1941      */
1942     @Test
1943     void testToFloatString() {
1944         assertEquals(NumberUtils.toFloat("-1.2345"), -1.2345f, "toFloat(String) 1 failed");
1945         assertEquals(1.2345f, NumberUtils.toFloat("1.2345"), "toFloat(String) 2 failed");
1946         assertEquals(0.0f, NumberUtils.toFloat("abc"), "toFloat(String) 3 failed");
1947         // LANG-1060
1948         assertEquals(NumberUtils.toFloat("-001.2345"), -1.2345f, "toFloat(String) 4 failed");
1949         assertEquals(1.2345f, NumberUtils.toFloat("+001.2345"), "toFloat(String) 5 failed");
1950         assertEquals(1.2345f, NumberUtils.toFloat("001.2345"), "toFloat(String) 6 failed");
1951         assertEquals(0f, NumberUtils.toFloat("000.00"), "toFloat(String) 7 failed");
1952         assertEquals(NumberUtils.toFloat(Float.MAX_VALUE + ""), Float.MAX_VALUE, "toFloat(Float.MAX_VALUE) failed");
1953         assertEquals(NumberUtils.toFloat(Float.MIN_VALUE + ""), Float.MIN_VALUE, "toFloat(Float.MIN_VALUE) failed");
1954         assertEquals(0.0f, NumberUtils.toFloat(""), "toFloat(empty) failed");
1955         assertEquals(0.0f, NumberUtils.toFloat(null), "toFloat(null) failed");
1956     }
1957 
1958     /**
1959      * Test for {@link NumberUtils#toFloat(String, float)}.
1960      */
1961     @Test
1962     void testToFloatStringF() {
1963         assertEquals(1.2345f, NumberUtils.toFloat("1.2345", 5.1f), "toFloat(String, int) 1 failed");
1964         assertEquals(5.0f, NumberUtils.toFloat("a", 5.0f), "toFloat(String, int) 2 failed");
1965         // LANG-1060
1966         assertEquals(5.0f, NumberUtils.toFloat("-001Z.2345", 5.0f), "toFloat(String, int) 3 failed");
1967         assertEquals(5.0f, NumberUtils.toFloat("+001AB.2345", 5.0f), "toFloat(String, int) 4 failed");
1968         assertEquals(5.0f, NumberUtils.toFloat("001Z.2345", 5.0f), "toFloat(String, int) 5 failed");
1969         assertEquals(5.0f, NumberUtils.toFloat("", 5.0f));
1970         assertEquals(5.0f, NumberUtils.toFloat(null, 5.0f));
1971     }
1972 
1973     /**
1974      * Test for {@link NumberUtils#toInt(String)}.
1975      */
1976     @Test
1977     void testToIntString() {
1978         assertEquals(12345, NumberUtils.toInt("12345"), "toInt(String) 1 failed");
1979         assertEquals(0, NumberUtils.toInt("abc"), "toInt(String) 2 failed");
1980         assertEquals(0, NumberUtils.toInt(""), "toInt(empty) failed");
1981         assertEquals(0, NumberUtils.toInt(null), "toInt(null) failed");
1982     }
1983 
1984     /**
1985      * Test for {@link NumberUtils#toInt(String, int)}.
1986      */
1987     @Test
1988     void testToIntStringI() {
1989         assertEquals(12345, NumberUtils.toInt("12345", 5), "toInt(String, int) 1 failed");
1990         assertEquals(5, NumberUtils.toInt("1234.5", 5), "toInt(String, int) 2 failed");
1991         assertEquals(5, NumberUtils.toInt("", 5));
1992         assertEquals(5, NumberUtils.toInt(null, 5));
1993     }
1994 
1995     /**
1996      * Test for {@link NumberUtils#toLong(String)}.
1997      */
1998     @Test
1999     void testToLongString() {
2000         assertEquals(12345L, NumberUtils.toLong("12345"), "toLong(String) 1 failed");
2001         assertEquals(0L, NumberUtils.toLong("abc"), "toLong(String) 2 failed");
2002         assertEquals(0L, NumberUtils.toLong("1L"), "toLong(String) 3 failed");
2003         assertEquals(0L, NumberUtils.toLong("1l"), "toLong(String) 4 failed");
2004         assertEquals(NumberUtils.toLong(Long.MAX_VALUE + ""), Long.MAX_VALUE, "toLong(Long.MAX_VALUE) failed");
2005         assertEquals(NumberUtils.toLong(Long.MIN_VALUE + ""), Long.MIN_VALUE, "toLong(Long.MIN_VALUE) failed");
2006         assertEquals(0L, NumberUtils.toLong(""), "toLong(empty) failed");
2007         assertEquals(0L, NumberUtils.toLong(null), "toLong(null) failed");
2008     }
2009 
2010     /**
2011      * Test for {@link NumberUtils#toLong(String, long)}.
2012      */
2013     @Test
2014     void testToLongStringL() {
2015         assertEquals(12345L, NumberUtils.toLong("12345", 5L), "toLong(String, long) 1 failed");
2016         assertEquals(5L, NumberUtils.toLong("1234.5", 5L), "toLong(String, long) 2 failed");
2017         assertEquals(5L, NumberUtils.toLong("", 5L));
2018         assertEquals(5L, NumberUtils.toLong(null, 5L));
2019     }
2020 
2021     /**
2022      * Test for {@link NumberUtils#toScaledBigDecimal(BigDecimal)}.
2023      */
2024     @Test
2025     void testToScaledBigDecimalBigDecimal() {
2026         assertEquals(NumberUtils.toScaledBigDecimal(BigDecimal.valueOf(123.456)), BigDecimal.valueOf(123.46), "toScaledBigDecimal(BigDecimal) 1 failed");
2027         // Test RoundingMode.HALF_EVEN default rounding.
2028         assertEquals(NumberUtils.toScaledBigDecimal(BigDecimal.valueOf(23.515)), BigDecimal.valueOf(23.52), "toScaledBigDecimal(BigDecimal) 2 failed");
2029         assertEquals(NumberUtils.toScaledBigDecimal(BigDecimal.valueOf(23.525)), BigDecimal.valueOf(23.52), "toScaledBigDecimal(BigDecimal) 3 failed");
2030         assertEquals("2352.00", NumberUtils.toScaledBigDecimal(BigDecimal.valueOf(23.525)).multiply(BigDecimal.valueOf(100)).toString(),
2031                 "toScaledBigDecimal(BigDecimal) 4 failed");
2032         assertEquals(NumberUtils.toScaledBigDecimal((BigDecimal) null), BigDecimal.ZERO, "toScaledBigDecimal(BigDecimal) 5 failed");
2033     }
2034 
2035     /**
2036      * Test for {@link NumberUtils#toScaledBigDecimal(BigDecimal, int, RoundingMode)}.
2037      */
2038     @Test
2039     void testToScaledBigDecimalBigDecimalIRM() {
2040         assertEquals(NumberUtils.toScaledBigDecimal(BigDecimal.valueOf(123.456), 1, RoundingMode.CEILING), BigDecimal.valueOf(123.5),
2041                 "toScaledBigDecimal(BigDecimal, int, RoundingMode) 1 failed");
2042         assertEquals(NumberUtils.toScaledBigDecimal(BigDecimal.valueOf(23.5159), 3, RoundingMode.FLOOR), BigDecimal.valueOf(23.515),
2043                 "toScaledBigDecimal(BigDecimal, int, RoundingMode) 2 failed");
2044         assertEquals(NumberUtils.toScaledBigDecimal(BigDecimal.valueOf(23.525), 2, RoundingMode.HALF_UP), BigDecimal.valueOf(23.53),
2045                 "toScaledBigDecimal(BigDecimal, int, RoundingMode) 3 failed");
2046         assertEquals("23521.0000",
2047                 NumberUtils.toScaledBigDecimal(BigDecimal.valueOf(23.521), 4, RoundingMode.HALF_EVEN).multiply(BigDecimal.valueOf(1000)).toString(),
2048                 "toScaledBigDecimal(BigDecimal, int, RoundingMode) 4 failed");
2049         assertEquals(NumberUtils.toScaledBigDecimal((BigDecimal) null, 2, RoundingMode.HALF_UP), BigDecimal.ZERO,
2050                 "toScaledBigDecimal(BigDecimal, int, RoundingMode) 5 failed");
2051     }
2052 
2053     /**
2054      * Test for {@link NumberUtils#toScaledBigDecimal(Double)}.
2055      */
2056     @Test
2057     void testToScaledBigDecimalDouble() {
2058         assertEquals(NumberUtils.toScaledBigDecimal(Double.valueOf(123.456d)), BigDecimal.valueOf(123.46), "toScaledBigDecimal(Double) 1 failed");
2059         // Test RoundingMode.HALF_EVEN default rounding.
2060         assertEquals(NumberUtils.toScaledBigDecimal(Double.valueOf(23.515d)), BigDecimal.valueOf(23.52), "toScaledBigDecimal(Double) 2 failed");
2061         assertEquals(NumberUtils.toScaledBigDecimal(Double.valueOf(23.525d)), BigDecimal.valueOf(23.52), "toScaledBigDecimal(Double) 3 failed");
2062         assertEquals("2352.00", NumberUtils.toScaledBigDecimal(Double.valueOf(23.525d)).multiply(BigDecimal.valueOf(100)).toString(),
2063                 "toScaledBigDecimal(Double) 4 failed");
2064         assertEquals(NumberUtils.toScaledBigDecimal((Double) null), BigDecimal.ZERO, "toScaledBigDecimal(Double) 5 failed");
2065     }
2066 
2067     /**
2068      * Test for {@link NumberUtils#toScaledBigDecimal(Double, int, RoundingMode)}.
2069      */
2070     @Test
2071     void testToScaledBigDecimalDoubleIRM() {
2072         assertEquals(NumberUtils.toScaledBigDecimal(Double.valueOf(123.456d), 1, RoundingMode.CEILING), BigDecimal.valueOf(123.5),
2073                 "toScaledBigDecimal(Double, int, RoundingMode) 1 failed");
2074         assertEquals(NumberUtils.toScaledBigDecimal(Double.valueOf(23.5159d), 3, RoundingMode.FLOOR), BigDecimal.valueOf(23.515),
2075                 "toScaledBigDecimal(Double, int, RoundingMode) 2 failed");
2076         assertEquals(NumberUtils.toScaledBigDecimal(Double.valueOf(23.525d), 2, RoundingMode.HALF_UP), BigDecimal.valueOf(23.53),
2077                 "toScaledBigDecimal(Double, int, RoundingMode) 3 failed");
2078         assertEquals("23521.0000",
2079                 NumberUtils.toScaledBigDecimal(Double.valueOf(23.521d), 4, RoundingMode.HALF_EVEN).multiply(BigDecimal.valueOf(1000)).toString(),
2080                 "toScaledBigDecimal(Double, int, RoundingMode) 4 failed");
2081         assertEquals(NumberUtils.toScaledBigDecimal((Double) null, 2, RoundingMode.HALF_UP), BigDecimal.ZERO,
2082                 "toScaledBigDecimal(Double, int, RoundingMode) 5 failed");
2083     }
2084 
2085     /**
2086      * Test for {@link NumberUtils#toScaledBigDecimal(Float)}.
2087      */
2088     @Test
2089     void testToScaledBigDecimalFloat() {
2090         assertEquals(NumberUtils.toScaledBigDecimal(Float.valueOf(123.456f)), BigDecimal.valueOf(123.46), "toScaledBigDecimal(Float) 1 failed");
2091         // Test RoundingMode.HALF_EVEN default rounding.
2092         assertEquals(NumberUtils.toScaledBigDecimal(Float.valueOf(23.515f)), BigDecimal.valueOf(23.51), "toScaledBigDecimal(Float) 2 failed");
2093         // Note. NumberUtils.toScaledBigDecimal(Float.valueOf(23.515f)).equals(BigDecimal.valueOf(23.51))
2094         // because of roundoff error. It is ok.
2095         assertEquals(NumberUtils.toScaledBigDecimal(Float.valueOf(23.525f)), BigDecimal.valueOf(23.52), "toScaledBigDecimal(Float) 3 failed");
2096         assertEquals("2352.00", NumberUtils.toScaledBigDecimal(Float.valueOf(23.525f)).multiply(BigDecimal.valueOf(100)).toString(),
2097                 "toScaledBigDecimal(Float) 4 failed");
2098         assertEquals(NumberUtils.toScaledBigDecimal((Float) null), BigDecimal.ZERO, "toScaledBigDecimal(Float) 5 failed");
2099     }
2100 
2101     /**
2102      * Test for {@link NumberUtils#toScaledBigDecimal(Float, int, RoundingMode)}.
2103      */
2104     @Test
2105     void testToScaledBigDecimalFloatIRM() {
2106         assertEquals(NumberUtils.toScaledBigDecimal(Float.valueOf(123.456f), 1, RoundingMode.CEILING), BigDecimal.valueOf(123.5),
2107                 "toScaledBigDecimal(Float, int, RoundingMode) 1 failed");
2108         assertEquals(NumberUtils.toScaledBigDecimal(Float.valueOf(23.5159f), 3, RoundingMode.FLOOR), BigDecimal.valueOf(23.515),
2109                 "toScaledBigDecimal(Float, int, RoundingMode) 2 failed");
2110         // The following happens due to roundoff error. We're ok with this.
2111         assertEquals(NumberUtils.toScaledBigDecimal(Float.valueOf(23.525f), 2, RoundingMode.HALF_UP), BigDecimal.valueOf(23.52),
2112                 "toScaledBigDecimal(Float, int, RoundingMode) 3 failed");
2113         assertEquals("23521.0000",
2114                 NumberUtils.toScaledBigDecimal(Float.valueOf(23.521f), 4, RoundingMode.HALF_EVEN).multiply(BigDecimal.valueOf(1000)).toString(),
2115                 "toScaledBigDecimal(Float, int, RoundingMode) 4 failed");
2116         assertEquals(NumberUtils.toScaledBigDecimal((Float) null, 2, RoundingMode.HALF_UP), BigDecimal.ZERO,
2117                 "toScaledBigDecimal(Float, int, RoundingMode) 5 failed");
2118     }
2119 
2120     /**
2121      * Test for {@link NumberUtils#toScaledBigDecimal(Double)}.
2122      */
2123     @Test
2124     void testToScaledBigDecimalString() {
2125         assertEquals(NumberUtils.toScaledBigDecimal("123.456"), BigDecimal.valueOf(123.46), "toScaledBigDecimal(String) 1 failed");
2126         // Test RoundingMode.HALF_EVEN default rounding.
2127         assertEquals(NumberUtils.toScaledBigDecimal("23.515"), BigDecimal.valueOf(23.52), "toScaledBigDecimal(String) 2 failed");
2128         assertEquals(NumberUtils.toScaledBigDecimal("23.525"), BigDecimal.valueOf(23.52), "toScaledBigDecimal(String) 3 failed");
2129         assertEquals("2352.00", NumberUtils.toScaledBigDecimal("23.525").multiply(BigDecimal.valueOf(100)).toString(), "toScaledBigDecimal(String) 4 failed");
2130         assertEquals(NumberUtils.toScaledBigDecimal((String) null), BigDecimal.ZERO, "toScaledBigDecimal(String) 5 failed");
2131     }
2132 
2133     /**
2134      * Test for {@link NumberUtils#toScaledBigDecimal(Double, int, RoundingMode)}.
2135      */
2136     @Test
2137     void testToScaledBigDecimalStringIRM() {
2138         assertEquals(NumberUtils.toScaledBigDecimal("123.456", 1, RoundingMode.CEILING), BigDecimal.valueOf(123.5),
2139                 "toScaledBigDecimal(String, int, RoundingMode) 1 failed");
2140         assertEquals(NumberUtils.toScaledBigDecimal("23.5159", 3, RoundingMode.FLOOR), BigDecimal.valueOf(23.515),
2141                 "toScaledBigDecimal(String, int, RoundingMode) 2 failed");
2142         assertEquals(NumberUtils.toScaledBigDecimal("23.525", 2, RoundingMode.HALF_UP), BigDecimal.valueOf(23.53),
2143                 "toScaledBigDecimal(String, int, RoundingMode) 3 failed");
2144         assertEquals("23521.0000", NumberUtils.toScaledBigDecimal("23.521", 4, RoundingMode.HALF_EVEN).multiply(BigDecimal.valueOf(1000)).toString(),
2145                 "toScaledBigDecimal(String, int, RoundingMode) 4 failed");
2146         assertEquals(NumberUtils.toScaledBigDecimal((String) null, 2, RoundingMode.HALF_UP), BigDecimal.ZERO,
2147                 "toScaledBigDecimal(String, int, RoundingMode) 5 failed");
2148     }
2149 
2150     /**
2151      * Test for {@link NumberUtils#toShort(String)}.
2152      */
2153     @Test
2154     void testToShortString() {
2155         assertEquals(12345, NumberUtils.toShort("12345"), "toShort(String) 1 failed");
2156         assertEquals(0, NumberUtils.toShort("abc"), "toShort(String) 2 failed");
2157         assertEquals(0, NumberUtils.toShort(""), "toShort(empty) failed");
2158         assertEquals(0, NumberUtils.toShort(null), "toShort(null) failed");
2159     }
2160 
2161     /**
2162      * Test for {@link NumberUtils#toShort(String, short)}.
2163      */
2164     @Test
2165     void testToShortStringI() {
2166         assertEquals(12345, NumberUtils.toShort("12345", (short) 5), "toShort(String, short) 1 failed");
2167         assertEquals(5, NumberUtils.toShort("1234.5", (short) 5), "toShort(String, short) 2 failed");
2168         assertEquals(5, NumberUtils.toShort("", (short) 5));
2169         assertEquals(5, NumberUtils.toShort(null, (short) 5));
2170     }
2171 }