1
2
3
4
5
6
7
8
9
10
11
12
13
14
15
16
17 package org.apache.commons.lang3.math;
18
19 import static org.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
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
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
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
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")
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
364 this.testCreateBigDecimalFailure("\u00A0\uFEFF\u000B\u000C\u001C\u001D\u001E\u001F");
365
366 this.testCreateBigDecimalFailure("-");
367
368 this.testCreateBigDecimalFailure("--");
369 this.testCreateBigDecimalFailure("--0");
370
371 this.testCreateBigDecimalFailure("+");
372
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
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
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
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
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
455 this.testCreateIntegerFailure("\u00A0\uFEFF\u000B\u000C\u001C\u001D\u001E\u001F");
456
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
473 this.testCreateLongFailure("\u00A0\uFEFF\u000B\u000C\u001C\u001D\u001E\u001F");
474
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
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
523 assertEquals(Float.valueOf("2."), NumberUtils.createNumber("2."), "createNumber(String) LANG-521 failed");
524
525
526 assertFalse(checkCreateNumber("1eE"), "createNumber(String) succeeded");
527
528
529 assertEquals(Double.valueOf(Double.MAX_VALUE), NumberUtils.createNumber("" + Double.MAX_VALUE),
530 "createNumber(String) LANG-693 failed");
531
532
533
534 final Number bigNum = NumberUtils.createNumber("-1.1E-700F");
535 assertNotNull(bigNum);
536 assertEquals(BigDecimal.class, bigNum.getClass());
537
538
539 assertEquals(Double.valueOf("-160952.54"), NumberUtils.createNumber("-160952.54"),
540 "createNumber(String) LANG-1018 failed");
541
542 assertEquals(Double.valueOf("6264583.33"), NumberUtils.createNumber("6264583.33"),
543 "createNumber(String) LANG-1187 failed");
544
545 assertEquals(Double.valueOf("193343.82"), NumberUtils.createNumber("193343.82"),
546 "createNumber(String) LANG-1215 failed");
547
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
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
587 public void testCreateNumberFailure_1() {
588 assertThrows(NumberFormatException.class, () -> NumberUtils.createNumber("--1.1E-700F"));
589 }
590
591 @Test
592
593 public void testCreateNumberFailure_2() {
594 assertThrows(NumberFormatException.class, () -> NumberUtils.createNumber("-1.1E+0-7e00"));
595 }
596
597 @Test
598
599 public void testCreateNumberFailure_3() {
600 assertThrows(NumberFormatException.class, () -> NumberUtils.createNumber("-11E+0-7e00"));
601 }
602
603 @Test
604
605 public void testCreateNumberFailure_4() {
606 assertThrows(NumberFormatException.class, () -> NumberUtils.createNumber("1eE+00001"));
607 }
608
609 @Test
610
611 public void testCreateNumberFailure_5() {
612 assertThrows(NumberFormatException.class, () -> NumberUtils.createNumber("1234.5ff"));
613 }
614
615 @Test
616
617 public void testCreateNumberFailure_6() {
618 assertThrows(NumberFormatException.class, () -> NumberUtils.createNumber("1234.5FF"));
619 }
620
621 @Test
622
623 public void testCreateNumberFailure_7() {
624 assertThrows(NumberFormatException.class, () -> NumberUtils.createNumber("1234.5dd"));
625 }
626
627 @Test
628
629 public void testCreateNumberFailure_8() {
630 assertThrows(NumberFormatException.class, () -> NumberUtils.createNumber("1234.5DD"));
631 }
632
633
634
635 @Test
636 public void testCreateNumberMagnitude() {
637
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
642 assertEquals(Double.valueOf(Double.MAX_VALUE), NumberUtils.createNumber("1.7976931348623157e+308"));
643
644 assertEquals(new BigDecimal("1.7976931348623159e+308"), NumberUtils.createNumber("1.7976931348623159e+308"));
645
646
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
651
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
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"));
673 assertEquals(Long.valueOf(037777777777L), NumberUtils.createNumber("037777777777"));
674
675
676 assertEquals(Long.valueOf(0777777777777777777777L), NumberUtils.createNumber("0777777777777777777777"));
677
678 assertEquals(new BigInteger("1777777777777777777777", 8), NumberUtils.createNumber("01777777777777777777777"));
679 }
680
681
682
683
684 @Test
685 public void testCreateNumberZero() {
686
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
693
694
695
696
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
706
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
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
726
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);
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);
780 compareIsCreatableWithCreateNumber("1.1L", false);
781 compareIsCreatableWithCreateNumber("+0xF", true);
782 compareIsCreatableWithCreateNumber("+0xFFFFFFFF", true);
783 compareIsCreatableWithCreateNumber("+0xFFFFFFFFFFFFFFFF", true);
784 compareIsCreatableWithCreateNumber(".0", true);
785 compareIsCreatableWithCreateNumber("0.", true);
786 compareIsCreatableWithCreateNumber("0.D", true);
787 compareIsCreatableWithCreateNumber("0e1", true);
788 compareIsCreatableWithCreateNumber("0e1D", true);
789 compareIsCreatableWithCreateNumber(".D", false);
790 compareIsCreatableWithCreateNumber(".e10", false);
791 compareIsCreatableWithCreateNumber(".e10D", false);
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
806
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);
866 compareIsNumberWithCreateNumber("1.1L", false);
867 compareIsNumberWithCreateNumber("+0xF", true);
868 compareIsNumberWithCreateNumber("+0xFFFFFFFF", true);
869 compareIsNumberWithCreateNumber("+0xFFFFFFFFFFFFFFFF", true);
870 compareIsNumberWithCreateNumber(".0", true);
871 compareIsNumberWithCreateNumber("0.", true);
872 compareIsNumberWithCreateNumber("0.D", true);
873 compareIsNumberWithCreateNumber("0e1", true);
874 compareIsNumberWithCreateNumber("0e1D", true);
875 compareIsNumberWithCreateNumber(".D", false);
876 compareIsNumberWithCreateNumber(".e10", false);
877 compareIsNumberWithCreateNumber(".e10D", false);
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
938 assertEquals(Float.class, NumberUtils.createNumber("0.0").getClass());
939 assertEquals(Float.valueOf("0.0"), NumberUtils.createNumber("0.0"));
940
941 assertEquals(Float.class, NumberUtils.createNumber("+0.0").getClass());
942 assertEquals(Float.valueOf("+0.0"), NumberUtils.createNumber("+0.0"));
943
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
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
1008 assertEquals(new BigInteger("8000000000000000", 16), NumberUtils.createNumber("0x8000000000000000"));
1009 assertEquals(new BigInteger("FFFFFFFFFFFFFFFF", 16), NumberUtils.createNumber("0xFFFFFFFFFFFFFFFF"));
1010
1011
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
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
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
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
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
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
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
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
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
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
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
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
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
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
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
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
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
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
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
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
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
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
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
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
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
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
1659 assertEquals(NumberUtils.toScaledBigDecimal(Float.valueOf(23.515f)), BigDecimal.valueOf(23.51),
1660 "toScaledBigDecimal(Float) 2 failed");
1661
1662
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
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
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
1692
1693 @Test
1694 public void testToScaledBigDecimalString() {
1695 assertEquals(NumberUtils.toScaledBigDecimal("123.456"), BigDecimal.valueOf(123.46),
1696 "toScaledBigDecimal(String) 1 failed");
1697
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
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
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
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 }