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