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 checkCreateNumber(final String val)40 private boolean checkCreateNumber(final String val) { 41 try { 42 final Object obj = NumberUtils.createNumber(val); 43 return obj != null; 44 } catch (final NumberFormatException e) { 45 return false; 46 } 47 } 48 49 @Test compareByte()50 public void compareByte() { 51 assertTrue(NumberUtils.compare((byte) -3, (byte) 0) < 0); 52 assertEquals(0, NumberUtils.compare((byte) 113, (byte) 113)); 53 assertTrue(NumberUtils.compare((byte) 123, (byte) 32) > 0); 54 } 55 56 @Test compareInt()57 public void compareInt() { 58 assertTrue(NumberUtils.compare(-3, 0) < 0); 59 assertEquals(0, NumberUtils.compare(113, 113)); 60 assertTrue(NumberUtils.compare(213, 32) > 0); 61 } 62 compareIsCreatableWithCreateNumber(final String val, final boolean expected)63 private void compareIsCreatableWithCreateNumber(final String val, final boolean expected) { 64 final boolean isValid = NumberUtils.isCreatable(val); 65 final boolean canCreate = checkCreateNumber(val); 66 assertTrue(isValid == expected && canCreate == expected, "Expecting " + expected 67 + " for isCreatable/createNumber using \"" + val + "\" but got " + isValid + " and " + canCreate); 68 } 69 70 @SuppressWarnings("deprecation") compareIsNumberWithCreateNumber(final String val, final boolean expected)71 private void compareIsNumberWithCreateNumber(final String val, final boolean expected) { 72 final boolean isValid = NumberUtils.isNumber(val); 73 final boolean canCreate = checkCreateNumber(val); 74 assertTrue(isValid == expected && canCreate == expected, "Expecting " + expected 75 + " for isNumber/createNumber using \"" + val + "\" but got " + isValid + " and " + canCreate); 76 } 77 78 @Test compareLong()79 public void compareLong() { 80 assertTrue(NumberUtils.compare(-3L, 0L) < 0); 81 assertEquals(0, NumberUtils.compare(113L, 113L)); 82 assertTrue(NumberUtils.compare(213L, 32L) > 0); 83 } 84 85 @Test compareShort()86 public void compareShort() { 87 assertTrue(NumberUtils.compare((short) -3, (short) 0) < 0); 88 assertEquals(0, NumberUtils.compare((short) 113, (short) 113)); 89 assertTrue(NumberUtils.compare((short) 213, (short) 32) > 0); 90 } 91 92 /** 93 * Test for {@link NumberUtils#toDouble(BigDecimal)} 94 */ 95 @Test testBigIntegerToDoubleBigInteger()96 public void testBigIntegerToDoubleBigInteger() { 97 assertEquals(0.0d, NumberUtils.toDouble((BigDecimal) null), "toDouble(BigInteger) 1 failed"); 98 assertEquals(8.5d, NumberUtils.toDouble(BigDecimal.valueOf(8.5d)), "toDouble(BigInteger) 2 failed"); 99 } 100 101 /** 102 * Test for {@link NumberUtils#toDouble(BigDecimal, double)} 103 */ 104 @Test testBigIntegerToDoubleBigIntegerD()105 public void testBigIntegerToDoubleBigIntegerD() { 106 assertEquals(1.1d, NumberUtils.toDouble((BigDecimal) null, 1.1d), "toDouble(BigInteger) 1 failed"); 107 assertEquals(8.5d, NumberUtils.toDouble(BigDecimal.valueOf(8.5d), 1.1d), "toDouble(BigInteger) 2 failed"); 108 } 109 110 // Testing JDK against old Lang functionality 111 @Test testCompareDouble()112 public void testCompareDouble() { 113 assertEquals(0, Double.compare(Double.NaN, Double.NaN)); 114 assertEquals(Double.compare(Double.NaN, Double.POSITIVE_INFINITY), +1); 115 assertEquals(Double.compare(Double.NaN, Double.MAX_VALUE), +1); 116 assertEquals(Double.compare(Double.NaN, 1.2d), +1); 117 assertEquals(Double.compare(Double.NaN, 0.0d), +1); 118 assertEquals(Double.compare(Double.NaN, -0.0d), +1); 119 assertEquals(Double.compare(Double.NaN, -1.2d), +1); 120 assertEquals(Double.compare(Double.NaN, -Double.MAX_VALUE), +1); 121 assertEquals(Double.compare(Double.NaN, Double.NEGATIVE_INFINITY), +1); 122 123 assertEquals(Double.compare(Double.POSITIVE_INFINITY, Double.NaN), -1); 124 assertEquals(0, Double.compare(Double.POSITIVE_INFINITY, Double.POSITIVE_INFINITY)); 125 assertEquals(Double.compare(Double.POSITIVE_INFINITY, Double.MAX_VALUE), +1); 126 assertEquals(Double.compare(Double.POSITIVE_INFINITY, 1.2d), +1); 127 assertEquals(Double.compare(Double.POSITIVE_INFINITY, 0.0d), +1); 128 assertEquals(Double.compare(Double.POSITIVE_INFINITY, -0.0d), +1); 129 assertEquals(Double.compare(Double.POSITIVE_INFINITY, -1.2d), +1); 130 assertEquals(Double.compare(Double.POSITIVE_INFINITY, -Double.MAX_VALUE), +1); 131 assertEquals(Double.compare(Double.POSITIVE_INFINITY, Double.NEGATIVE_INFINITY), +1); 132 133 assertEquals(Double.compare(Double.MAX_VALUE, Double.NaN), -1); 134 assertEquals(Double.compare(Double.MAX_VALUE, Double.POSITIVE_INFINITY), -1); 135 assertEquals(0, Double.compare(Double.MAX_VALUE, Double.MAX_VALUE)); 136 assertEquals(Double.compare(Double.MAX_VALUE, 1.2d), +1); 137 assertEquals(Double.compare(Double.MAX_VALUE, 0.0d), +1); 138 assertEquals(Double.compare(Double.MAX_VALUE, -0.0d), +1); 139 assertEquals(Double.compare(Double.MAX_VALUE, -1.2d), +1); 140 assertEquals(Double.compare(Double.MAX_VALUE, -Double.MAX_VALUE), +1); 141 assertEquals(Double.compare(Double.MAX_VALUE, Double.NEGATIVE_INFINITY), +1); 142 143 assertEquals(Double.compare(1.2d, Double.NaN), -1); 144 assertEquals(Double.compare(1.2d, Double.POSITIVE_INFINITY), -1); 145 assertEquals(Double.compare(1.2d, Double.MAX_VALUE), -1); 146 assertEquals(0, Double.compare(1.2d, 1.2d)); 147 assertEquals(Double.compare(1.2d, 0.0d), +1); 148 assertEquals(Double.compare(1.2d, -0.0d), +1); 149 assertEquals(Double.compare(1.2d, -1.2d), +1); 150 assertEquals(Double.compare(1.2d, -Double.MAX_VALUE), +1); 151 assertEquals(Double.compare(1.2d, Double.NEGATIVE_INFINITY), +1); 152 153 assertEquals(Double.compare(0.0d, Double.NaN), -1); 154 assertEquals(Double.compare(0.0d, Double.POSITIVE_INFINITY), -1); 155 assertEquals(Double.compare(0.0d, Double.MAX_VALUE), -1); 156 assertEquals(Double.compare(0.0d, 1.2d), -1); 157 assertEquals(0, Double.compare(0.0d, 0.0d)); 158 assertEquals(Double.compare(0.0d, -0.0d), +1); 159 assertEquals(Double.compare(0.0d, -1.2d), +1); 160 assertEquals(Double.compare(0.0d, -Double.MAX_VALUE), +1); 161 assertEquals(Double.compare(0.0d, Double.NEGATIVE_INFINITY), +1); 162 163 assertEquals(Double.compare(-0.0d, Double.NaN), -1); 164 assertEquals(Double.compare(-0.0d, Double.POSITIVE_INFINITY), -1); 165 assertEquals(Double.compare(-0.0d, Double.MAX_VALUE), -1); 166 assertEquals(Double.compare(-0.0d, 1.2d), -1); 167 assertEquals(Double.compare(-0.0d, 0.0d), -1); 168 assertEquals(0, Double.compare(-0.0d, -0.0d)); 169 assertEquals(Double.compare(-0.0d, -1.2d), +1); 170 assertEquals(Double.compare(-0.0d, -Double.MAX_VALUE), +1); 171 assertEquals(Double.compare(-0.0d, Double.NEGATIVE_INFINITY), +1); 172 173 assertEquals(Double.compare(-1.2d, Double.NaN), -1); 174 assertEquals(Double.compare(-1.2d, Double.POSITIVE_INFINITY), -1); 175 assertEquals(Double.compare(-1.2d, Double.MAX_VALUE), -1); 176 assertEquals(Double.compare(-1.2d, 1.2d), -1); 177 assertEquals(Double.compare(-1.2d, 0.0d), -1); 178 assertEquals(Double.compare(-1.2d, -0.0d), -1); 179 assertEquals(0, Double.compare(-1.2d, -1.2d)); 180 assertEquals(Double.compare(-1.2d, -Double.MAX_VALUE), +1); 181 assertEquals(Double.compare(-1.2d, Double.NEGATIVE_INFINITY), +1); 182 183 assertEquals(Double.compare(-Double.MAX_VALUE, Double.NaN), -1); 184 assertEquals(Double.compare(-Double.MAX_VALUE, Double.POSITIVE_INFINITY), -1); 185 assertEquals(Double.compare(-Double.MAX_VALUE, Double.MAX_VALUE), -1); 186 assertEquals(Double.compare(-Double.MAX_VALUE, 1.2d), -1); 187 assertEquals(Double.compare(-Double.MAX_VALUE, 0.0d), -1); 188 assertEquals(Double.compare(-Double.MAX_VALUE, -0.0d), -1); 189 assertEquals(Double.compare(-Double.MAX_VALUE, -1.2d), -1); 190 assertEquals(0, Double.compare(-Double.MAX_VALUE, -Double.MAX_VALUE)); 191 assertEquals(Double.compare(-Double.MAX_VALUE, Double.NEGATIVE_INFINITY), +1); 192 193 assertEquals(Double.compare(Double.NEGATIVE_INFINITY, Double.NaN), -1); 194 assertEquals(Double.compare(Double.NEGATIVE_INFINITY, Double.POSITIVE_INFINITY), -1); 195 assertEquals(Double.compare(Double.NEGATIVE_INFINITY, Double.MAX_VALUE), -1); 196 assertEquals(Double.compare(Double.NEGATIVE_INFINITY, 1.2d), -1); 197 assertEquals(Double.compare(Double.NEGATIVE_INFINITY, 0.0d), -1); 198 assertEquals(Double.compare(Double.NEGATIVE_INFINITY, -0.0d), -1); 199 assertEquals(Double.compare(Double.NEGATIVE_INFINITY, -1.2d), -1); 200 assertEquals(Double.compare(Double.NEGATIVE_INFINITY, -Double.MAX_VALUE), -1); 201 assertEquals(0, Double.compare(Double.NEGATIVE_INFINITY, Double.NEGATIVE_INFINITY)); 202 } 203 204 @Test testCompareFloat()205 public void testCompareFloat() { 206 assertEquals(0, Float.compare(Float.NaN, Float.NaN)); 207 assertEquals(Float.compare(Float.NaN, Float.POSITIVE_INFINITY), +1); 208 assertEquals(Float.compare(Float.NaN, Float.MAX_VALUE), +1); 209 assertEquals(Float.compare(Float.NaN, 1.2f), +1); 210 assertEquals(Float.compare(Float.NaN, 0.0f), +1); 211 assertEquals(Float.compare(Float.NaN, -0.0f), +1); 212 assertEquals(Float.compare(Float.NaN, -1.2f), +1); 213 assertEquals(Float.compare(Float.NaN, -Float.MAX_VALUE), +1); 214 assertEquals(Float.compare(Float.NaN, Float.NEGATIVE_INFINITY), +1); 215 216 assertEquals(Float.compare(Float.POSITIVE_INFINITY, Float.NaN), -1); 217 assertEquals(0, Float.compare(Float.POSITIVE_INFINITY, Float.POSITIVE_INFINITY)); 218 assertEquals(Float.compare(Float.POSITIVE_INFINITY, Float.MAX_VALUE), +1); 219 assertEquals(Float.compare(Float.POSITIVE_INFINITY, 1.2f), +1); 220 assertEquals(Float.compare(Float.POSITIVE_INFINITY, 0.0f), +1); 221 assertEquals(Float.compare(Float.POSITIVE_INFINITY, -0.0f), +1); 222 assertEquals(Float.compare(Float.POSITIVE_INFINITY, -1.2f), +1); 223 assertEquals(Float.compare(Float.POSITIVE_INFINITY, -Float.MAX_VALUE), +1); 224 assertEquals(Float.compare(Float.POSITIVE_INFINITY, Float.NEGATIVE_INFINITY), +1); 225 226 assertEquals(Float.compare(Float.MAX_VALUE, Float.NaN), -1); 227 assertEquals(Float.compare(Float.MAX_VALUE, Float.POSITIVE_INFINITY), -1); 228 assertEquals(0, Float.compare(Float.MAX_VALUE, Float.MAX_VALUE)); 229 assertEquals(Float.compare(Float.MAX_VALUE, 1.2f), +1); 230 assertEquals(Float.compare(Float.MAX_VALUE, 0.0f), +1); 231 assertEquals(Float.compare(Float.MAX_VALUE, -0.0f), +1); 232 assertEquals(Float.compare(Float.MAX_VALUE, -1.2f), +1); 233 assertEquals(Float.compare(Float.MAX_VALUE, -Float.MAX_VALUE), +1); 234 assertEquals(Float.compare(Float.MAX_VALUE, Float.NEGATIVE_INFINITY), +1); 235 236 assertEquals(Float.compare(1.2f, Float.NaN), -1); 237 assertEquals(Float.compare(1.2f, Float.POSITIVE_INFINITY), -1); 238 assertEquals(Float.compare(1.2f, Float.MAX_VALUE), -1); 239 assertEquals(0, Float.compare(1.2f, 1.2f)); 240 assertEquals(Float.compare(1.2f, 0.0f), +1); 241 assertEquals(Float.compare(1.2f, -0.0f), +1); 242 assertEquals(Float.compare(1.2f, -1.2f), +1); 243 assertEquals(Float.compare(1.2f, -Float.MAX_VALUE), +1); 244 assertEquals(Float.compare(1.2f, Float.NEGATIVE_INFINITY), +1); 245 246 assertEquals(Float.compare(0.0f, Float.NaN), -1); 247 assertEquals(Float.compare(0.0f, Float.POSITIVE_INFINITY), -1); 248 assertEquals(Float.compare(0.0f, Float.MAX_VALUE), -1); 249 assertEquals(Float.compare(0.0f, 1.2f), -1); 250 assertEquals(0, Float.compare(0.0f, 0.0f)); 251 assertEquals(Float.compare(0.0f, -0.0f), +1); 252 assertEquals(Float.compare(0.0f, -1.2f), +1); 253 assertEquals(Float.compare(0.0f, -Float.MAX_VALUE), +1); 254 assertEquals(Float.compare(0.0f, Float.NEGATIVE_INFINITY), +1); 255 256 assertEquals(Float.compare(-0.0f, Float.NaN), -1); 257 assertEquals(Float.compare(-0.0f, Float.POSITIVE_INFINITY), -1); 258 assertEquals(Float.compare(-0.0f, Float.MAX_VALUE), -1); 259 assertEquals(Float.compare(-0.0f, 1.2f), -1); 260 assertEquals(Float.compare(-0.0f, 0.0f), -1); 261 assertEquals(0, Float.compare(-0.0f, -0.0f)); 262 assertEquals(Float.compare(-0.0f, -1.2f), +1); 263 assertEquals(Float.compare(-0.0f, -Float.MAX_VALUE), +1); 264 assertEquals(Float.compare(-0.0f, Float.NEGATIVE_INFINITY), +1); 265 266 assertEquals(Float.compare(-1.2f, Float.NaN), -1); 267 assertEquals(Float.compare(-1.2f, Float.POSITIVE_INFINITY), -1); 268 assertEquals(Float.compare(-1.2f, Float.MAX_VALUE), -1); 269 assertEquals(Float.compare(-1.2f, 1.2f), -1); 270 assertEquals(Float.compare(-1.2f, 0.0f), -1); 271 assertEquals(Float.compare(-1.2f, -0.0f), -1); 272 assertEquals(0, Float.compare(-1.2f, -1.2f)); 273 assertEquals(Float.compare(-1.2f, -Float.MAX_VALUE), +1); 274 assertEquals(Float.compare(-1.2f, Float.NEGATIVE_INFINITY), +1); 275 276 assertEquals(Float.compare(-Float.MAX_VALUE, Float.NaN), -1); 277 assertEquals(Float.compare(-Float.MAX_VALUE, Float.POSITIVE_INFINITY), -1); 278 assertEquals(Float.compare(-Float.MAX_VALUE, Float.MAX_VALUE), -1); 279 assertEquals(Float.compare(-Float.MAX_VALUE, 1.2f), -1); 280 assertEquals(Float.compare(-Float.MAX_VALUE, 0.0f), -1); 281 assertEquals(Float.compare(-Float.MAX_VALUE, -0.0f), -1); 282 assertEquals(Float.compare(-Float.MAX_VALUE, -1.2f), -1); 283 assertEquals(0, Float.compare(-Float.MAX_VALUE, -Float.MAX_VALUE)); 284 assertEquals(Float.compare(-Float.MAX_VALUE, Float.NEGATIVE_INFINITY), +1); 285 286 assertEquals(Float.compare(Float.NEGATIVE_INFINITY, Float.NaN), -1); 287 assertEquals(Float.compare(Float.NEGATIVE_INFINITY, Float.POSITIVE_INFINITY), -1); 288 assertEquals(Float.compare(Float.NEGATIVE_INFINITY, Float.MAX_VALUE), -1); 289 assertEquals(Float.compare(Float.NEGATIVE_INFINITY, 1.2f), -1); 290 assertEquals(Float.compare(Float.NEGATIVE_INFINITY, 0.0f), -1); 291 assertEquals(Float.compare(Float.NEGATIVE_INFINITY, -0.0f), -1); 292 assertEquals(Float.compare(Float.NEGATIVE_INFINITY, -1.2f), -1); 293 assertEquals(Float.compare(Float.NEGATIVE_INFINITY, -Float.MAX_VALUE), -1); 294 assertEquals(0, Float.compare(Float.NEGATIVE_INFINITY, Float.NEGATIVE_INFINITY)); 295 } 296 297 @SuppressWarnings("cast") // suppress instanceof warning check 298 @Test testConstants()299 public void testConstants() { 300 assertTrue(NumberUtils.LONG_ZERO instanceof Long); 301 assertTrue(NumberUtils.LONG_ONE instanceof Long); 302 assertTrue(NumberUtils.LONG_MINUS_ONE instanceof Long); 303 assertTrue(NumberUtils.INTEGER_ZERO instanceof Integer); 304 assertTrue(NumberUtils.INTEGER_ONE instanceof Integer); 305 assertTrue(NumberUtils.INTEGER_MINUS_ONE instanceof Integer); 306 assertTrue(NumberUtils.SHORT_ZERO instanceof Short); 307 assertTrue(NumberUtils.SHORT_ONE instanceof Short); 308 assertTrue(NumberUtils.SHORT_MINUS_ONE instanceof Short); 309 assertTrue(NumberUtils.BYTE_ZERO instanceof Byte); 310 assertTrue(NumberUtils.BYTE_ONE instanceof Byte); 311 assertTrue(NumberUtils.BYTE_MINUS_ONE instanceof Byte); 312 assertTrue(NumberUtils.DOUBLE_ZERO instanceof Double); 313 assertTrue(NumberUtils.DOUBLE_ONE instanceof Double); 314 assertTrue(NumberUtils.DOUBLE_MINUS_ONE instanceof Double); 315 assertTrue(NumberUtils.FLOAT_ZERO instanceof Float); 316 assertTrue(NumberUtils.FLOAT_ONE instanceof Float); 317 assertTrue(NumberUtils.FLOAT_MINUS_ONE instanceof Float); 318 319 assertEquals(0, NumberUtils.LONG_ZERO.longValue()); 320 assertEquals(1, NumberUtils.LONG_ONE.longValue()); 321 assertEquals(NumberUtils.LONG_MINUS_ONE.longValue(), -1); 322 assertEquals(0, NumberUtils.INTEGER_ZERO.intValue()); 323 assertEquals(1, NumberUtils.INTEGER_ONE.intValue()); 324 assertEquals(NumberUtils.INTEGER_MINUS_ONE.intValue(), -1); 325 assertEquals(0, NumberUtils.SHORT_ZERO.shortValue()); 326 assertEquals(1, NumberUtils.SHORT_ONE.shortValue()); 327 assertEquals(NumberUtils.SHORT_MINUS_ONE.shortValue(), -1); 328 assertEquals(0, NumberUtils.BYTE_ZERO.byteValue()); 329 assertEquals(1, NumberUtils.BYTE_ONE.byteValue()); 330 assertEquals(NumberUtils.BYTE_MINUS_ONE.byteValue(), -1); 331 assertEquals(0.0d, NumberUtils.DOUBLE_ZERO.doubleValue()); 332 assertEquals(1.0d, NumberUtils.DOUBLE_ONE.doubleValue()); 333 assertEquals(NumberUtils.DOUBLE_MINUS_ONE.doubleValue(), -1.0d); 334 assertEquals(0.0f, NumberUtils.FLOAT_ZERO.floatValue()); 335 assertEquals(1.0f, NumberUtils.FLOAT_ONE.floatValue()); 336 assertEquals(NumberUtils.FLOAT_MINUS_ONE.floatValue(), -1.0f); 337 } 338 339 @Test testConstructor()340 public void testConstructor() { 341 assertNotNull(new NumberUtils()); 342 final Constructor<?>[] cons = NumberUtils.class.getDeclaredConstructors(); 343 assertEquals(1, cons.length); 344 assertTrue(Modifier.isPublic(cons[0].getModifiers())); 345 assertTrue(Modifier.isPublic(NumberUtils.class.getModifiers())); 346 assertFalse(Modifier.isFinal(NumberUtils.class.getModifiers())); 347 } 348 349 @Test testCreateBigDecimal()350 public void testCreateBigDecimal() { 351 assertEquals(new BigDecimal("1234.5"), NumberUtils.createBigDecimal("1234.5"), 352 "createBigDecimal(String) failed"); 353 assertNull(NumberUtils.createBigDecimal(null), "createBigDecimal(null) failed"); 354 this.testCreateBigDecimalFailure(""); 355 this.testCreateBigDecimalFailure(" "); 356 this.testCreateBigDecimalFailure("\b\t\n\f\r"); 357 // Funky whitespaces 358 this.testCreateBigDecimalFailure("\u00A0\uFEFF\u000B\u000C\u001C\u001D\u001E\u001F"); 359 // sign alone not valid 360 this.testCreateBigDecimalFailure("-"); 361 // comment in NumberUtils suggests some implementations may incorrectly allow this 362 this.testCreateBigDecimalFailure("--"); 363 this.testCreateBigDecimalFailure("--0"); 364 // sign alone not valid 365 this.testCreateBigDecimalFailure("+"); 366 // in case this was also allowed by some JVMs 367 this.testCreateBigDecimalFailure("++"); 368 this.testCreateBigDecimalFailure("++0"); 369 } 370 testCreateBigDecimalFailure(final String str)371 protected void testCreateBigDecimalFailure(final String str) { 372 assertThrows(NumberFormatException.class, () -> NumberUtils.createBigDecimal(str), 373 "createBigDecimal(\"" + str + "\") should have failed."); 374 } 375 376 @Test testCreateBigInteger()377 public void testCreateBigInteger() { 378 assertEquals(new BigInteger("12345"), NumberUtils.createBigInteger("12345"), "createBigInteger(String) failed"); 379 assertNull(NumberUtils.createBigInteger(null), "createBigInteger(null) failed"); 380 this.testCreateBigIntegerFailure(""); 381 this.testCreateBigIntegerFailure(" "); 382 this.testCreateBigIntegerFailure("\b\t\n\f\r"); 383 // Funky whitespaces 384 this.testCreateBigIntegerFailure("\u00A0\uFEFF\u000B\u000C\u001C\u001D\u001E\u001F"); 385 assertEquals(new BigInteger("255"), NumberUtils.createBigInteger("0xff"), "createBigInteger(String) failed"); 386 assertEquals(new BigInteger("255"), NumberUtils.createBigInteger("0Xff"), "createBigInteger(String) failed"); 387 assertEquals(new BigInteger("255"), NumberUtils.createBigInteger("#ff"), "createBigInteger(String) failed"); 388 assertEquals(new BigInteger("-255"), NumberUtils.createBigInteger("-0xff"), "createBigInteger(String) failed"); 389 assertEquals(new BigInteger("255"), NumberUtils.createBigInteger("0377"), "createBigInteger(String) failed"); 390 assertEquals(new BigInteger("-255"), NumberUtils.createBigInteger("-0377"), "createBigInteger(String) failed"); 391 assertEquals(new BigInteger("-255"), NumberUtils.createBigInteger("-0377"), "createBigInteger(String) failed"); 392 assertEquals(new BigInteger("-0"), NumberUtils.createBigInteger("-0"), "createBigInteger(String) failed"); 393 assertEquals(new BigInteger("0"), NumberUtils.createBigInteger("0"), "createBigInteger(String) failed"); 394 testCreateBigIntegerFailure("#"); 395 testCreateBigIntegerFailure("-#"); 396 testCreateBigIntegerFailure("0x"); 397 testCreateBigIntegerFailure("-0x"); 398 // LANG-1645 399 assertEquals(new BigInteger("+FFFFFFFFFFFFFFFF", 16), NumberUtils.createBigInteger("+0xFFFFFFFFFFFFFFFF")); 400 assertEquals(new BigInteger("+FFFFFFFFFFFFFFFF", 16), NumberUtils.createBigInteger("+#FFFFFFFFFFFFFFFF")); 401 assertEquals(new BigInteger("+1234567", 8), NumberUtils.createBigInteger("+01234567")); 402 } 403 testCreateBigIntegerFailure(final String str)404 protected void testCreateBigIntegerFailure(final String str) { 405 assertThrows(NumberFormatException.class, () -> NumberUtils.createBigInteger(str), 406 "createBigInteger(\"" + str + "\") should have failed."); 407 } 408 409 @Test testCreateDouble()410 public void testCreateDouble() { 411 assertEquals(Double.valueOf("1234.5"), NumberUtils.createDouble("1234.5"), "createDouble(String) failed"); 412 assertNull(NumberUtils.createDouble(null), "createDouble(null) failed"); 413 this.testCreateDoubleFailure(""); 414 this.testCreateDoubleFailure(" "); 415 this.testCreateDoubleFailure("\b\t\n\f\r"); 416 // Funky whitespaces 417 this.testCreateDoubleFailure("\u00A0\uFEFF\u000B\u000C\u001C\u001D\u001E\u001F"); 418 } 419 testCreateDoubleFailure(final String str)420 protected void testCreateDoubleFailure(final String str) { 421 assertThrows(NumberFormatException.class, () -> NumberUtils.createDouble(str), 422 "createDouble(\"" + str + "\") should have failed."); 423 } 424 425 @Test testCreateFloat()426 public void testCreateFloat() { 427 assertEquals(Float.valueOf("1234.5"), NumberUtils.createFloat("1234.5"), "createFloat(String) failed"); 428 assertNull(NumberUtils.createFloat(null), "createFloat(null) failed"); 429 this.testCreateFloatFailure(""); 430 this.testCreateFloatFailure(" "); 431 this.testCreateFloatFailure("\b\t\n\f\r"); 432 // Funky whitespaces 433 this.testCreateFloatFailure("\u00A0\uFEFF\u000B\u000C\u001C\u001D\u001E\u001F"); 434 } 435 testCreateFloatFailure(final String str)436 protected void testCreateFloatFailure(final String str) { 437 assertThrows(NumberFormatException.class, () -> NumberUtils.createFloat(str), 438 "createFloat(\"" + str + "\") should have failed."); 439 } 440 441 @Test testCreateInteger()442 public void testCreateInteger() { 443 assertEquals(Integer.valueOf("12345"), NumberUtils.createInteger("12345"), "createInteger(String) failed"); 444 assertNull(NumberUtils.createInteger(null), "createInteger(null) failed"); 445 this.testCreateIntegerFailure(""); 446 this.testCreateIntegerFailure(" "); 447 this.testCreateIntegerFailure("\b\t\n\f\r"); 448 // Funky whitespaces 449 this.testCreateIntegerFailure("\u00A0\uFEFF\u000B\u000C\u001C\u001D\u001E\u001F"); 450 // LANG-1645 451 assertEquals(Integer.decode("+0xF"), NumberUtils.createInteger("+0xF")); 452 } 453 testCreateIntegerFailure(final String str)454 protected void testCreateIntegerFailure(final String str) { 455 assertThrows(NumberFormatException.class, () -> NumberUtils.createInteger(str), 456 "createInteger(\"" + str + "\") should have failed."); 457 } 458 459 @Test testCreateLong()460 public void testCreateLong() { 461 assertEquals(Long.valueOf("12345"), NumberUtils.createLong("12345"), "createLong(String) failed"); 462 assertNull(NumberUtils.createLong(null), "createLong(null) failed"); 463 this.testCreateLongFailure(""); 464 this.testCreateLongFailure(" "); 465 this.testCreateLongFailure("\b\t\n\f\r"); 466 // Funky whitespaces 467 this.testCreateLongFailure("\u00A0\uFEFF\u000B\u000C\u001C\u001D\u001E\u001F"); 468 // LANG-1645 469 assertEquals(Long.decode("+0xFFFFFFFF"), NumberUtils.createLong("+0xFFFFFFFF")); 470 } 471 testCreateLongFailure(final String str)472 protected void testCreateLongFailure(final String str) { 473 assertThrows(NumberFormatException.class, () -> NumberUtils.createLong(str), 474 "createLong(\"" + str + "\") should have failed."); 475 } 476 477 @Test testCreateNumber()478 public void testCreateNumber() { 479 // a lot of things can go wrong 480 assertEquals(Float.valueOf("1234.5"), NumberUtils.createNumber("1234.5"), "createNumber(String) 1 failed"); 481 assertEquals(Integer.valueOf("12345"), NumberUtils.createNumber("12345"), "createNumber(String) 2 failed"); 482 assertEquals(Double.valueOf("1234.5"), NumberUtils.createNumber("1234.5D"), "createNumber(String) 3 failed"); 483 assertEquals(Double.valueOf("1234.5"), NumberUtils.createNumber("1234.5d"), "createNumber(String) 3 failed"); 484 assertEquals(Float.valueOf("1234.5"), NumberUtils.createNumber("1234.5F"), "createNumber(String) 4 failed"); 485 assertEquals(Float.valueOf("1234.5"), NumberUtils.createNumber("1234.5f"), "createNumber(String) 4 failed"); 486 assertEquals(Long.valueOf(Integer.MAX_VALUE + 1L), NumberUtils.createNumber("" + (Integer.MAX_VALUE + 1L)), 487 "createNumber(String) 5 failed"); 488 assertEquals(Long.valueOf(12345), NumberUtils.createNumber("12345L"), "createNumber(String) 6 failed"); 489 assertEquals(Long.valueOf(12345), NumberUtils.createNumber("12345l"), "createNumber(String) 6 failed"); 490 assertEquals(Float.valueOf("-1234.5"), NumberUtils.createNumber("-1234.5"), "createNumber(String) 7 failed"); 491 assertEquals(Integer.valueOf("-12345"), NumberUtils.createNumber("-12345"), "createNumber(String) 8 failed"); 492 assertEquals(0xFADE, NumberUtils.createNumber("0xFADE").intValue(), "createNumber(String) 9a failed"); 493 assertEquals(0xFADE, NumberUtils.createNumber("0Xfade").intValue(), "createNumber(String) 9b failed"); 494 assertEquals(-0xFADE, NumberUtils.createNumber("-0xFADE").intValue(), "createNumber(String) 10a failed"); 495 assertEquals(-0xFADE, NumberUtils.createNumber("-0Xfade").intValue(), "createNumber(String) 10b failed"); 496 assertEquals(Double.valueOf("1.1E200"), NumberUtils.createNumber("1.1E200"), "createNumber(String) 11 failed"); 497 assertEquals(Float.valueOf("1.1E20"), NumberUtils.createNumber("1.1E20"), "createNumber(String) 12 failed"); 498 assertEquals(Double.valueOf("-1.1E200"), NumberUtils.createNumber("-1.1E200"), 499 "createNumber(String) 13 failed"); 500 assertEquals(Double.valueOf("1.1E-200"), NumberUtils.createNumber("1.1E-200"), 501 "createNumber(String) 14 failed"); 502 assertNull(NumberUtils.createNumber(null), "createNumber(null) failed"); 503 assertEquals(new BigInteger("12345678901234567890"), NumberUtils.createNumber("12345678901234567890L"), 504 "createNumber(String) failed"); 505 506 assertEquals(new BigDecimal("1.1E-700"), NumberUtils.createNumber("1.1E-700F"), 507 "createNumber(String) 15 failed"); 508 509 assertEquals(Long.valueOf("10" + Integer.MAX_VALUE), NumberUtils.createNumber("10" + Integer.MAX_VALUE + "L"), 510 "createNumber(String) 16 failed"); 511 assertEquals(Long.valueOf("10" + Integer.MAX_VALUE), NumberUtils.createNumber("10" + Integer.MAX_VALUE), 512 "createNumber(String) 17 failed"); 513 assertEquals(new BigInteger("10" + Long.MAX_VALUE), NumberUtils.createNumber("10" + Long.MAX_VALUE), 514 "createNumber(String) 18 failed"); 515 516 // LANG-521 517 assertEquals(Float.valueOf("2."), NumberUtils.createNumber("2."), "createNumber(String) LANG-521 failed"); 518 519 // LANG-638 520 assertFalse(checkCreateNumber("1eE"), "createNumber(String) succeeded"); 521 522 // LANG-693 523 assertEquals(Double.valueOf(Double.MAX_VALUE), NumberUtils.createNumber("" + Double.MAX_VALUE), 524 "createNumber(String) LANG-693 failed"); 525 526 // LANG-822 527 // ensure that the underlying negative number would create a BigDecimal 528 final Number bigNum = NumberUtils.createNumber("-1.1E-700F"); 529 assertNotNull(bigNum); 530 assertEquals(BigDecimal.class, bigNum.getClass()); 531 532 // LANG-1018 533 assertEquals(Double.valueOf("-160952.54"), NumberUtils.createNumber("-160952.54"), 534 "createNumber(String) LANG-1018 failed"); 535 // LANG-1187 536 assertEquals(Double.valueOf("6264583.33"), NumberUtils.createNumber("6264583.33"), 537 "createNumber(String) LANG-1187 failed"); 538 // LANG-1215 539 assertEquals(Double.valueOf("193343.82"), NumberUtils.createNumber("193343.82"), 540 "createNumber(String) LANG-1215 failed"); 541 // LANG-1060 542 assertEquals(Double.valueOf("001234.5678"), NumberUtils.createNumber("001234.5678"), 543 "createNumber(String) LANG-1060a failed"); 544 assertEquals(Double.valueOf("+001234.5678"), NumberUtils.createNumber("+001234.5678"), 545 "createNumber(String) LANG-1060b failed"); 546 assertEquals(Double.valueOf("-001234.5678"), NumberUtils.createNumber("-001234.5678"), 547 "createNumber(String) LANG-1060c failed"); 548 assertEquals(Double.valueOf("0000.00000"), NumberUtils.createNumber("0000.00000d"), 549 "createNumber(String) LANG-1060d failed"); 550 assertEquals(Float.valueOf("001234.56"), NumberUtils.createNumber("001234.56"), 551 "createNumber(String) LANG-1060e failed"); 552 assertEquals(Float.valueOf("+001234.56"), NumberUtils.createNumber("+001234.56"), 553 "createNumber(String) LANG-1060f failed"); 554 assertEquals(Float.valueOf("-001234.56"), NumberUtils.createNumber("-001234.56"), 555 "createNumber(String) LANG-1060g failed"); 556 assertEquals(Float.valueOf("0000.10"), NumberUtils.createNumber("0000.10"), 557 "createNumber(String) LANG-1060h failed"); 558 assertEquals(Float.valueOf("001.1E20"), NumberUtils.createNumber("001.1E20"), 559 "createNumber(String) LANG-1060i failed"); 560 assertEquals(Float.valueOf("+001.1E20"), NumberUtils.createNumber("+001.1E20"), 561 "createNumber(String) LANG-1060j failed"); 562 assertEquals(Float.valueOf("-001.1E20"), NumberUtils.createNumber("-001.1E20"), 563 "createNumber(String) LANG-1060k failed"); 564 assertEquals(Double.valueOf("001.1E200"), NumberUtils.createNumber("001.1E200"), 565 "createNumber(String) LANG-1060l failed"); 566 assertEquals(Double.valueOf("+001.1E200"), NumberUtils.createNumber("+001.1E200"), 567 "createNumber(String) LANG-1060m failed"); 568 assertEquals(Double.valueOf("-001.1E200"), NumberUtils.createNumber("-001.1E200"), 569 "createNumber(String) LANG-1060n failed"); 570 // LANG-1645 571 assertEquals(Integer.decode("+0xF"), NumberUtils.createNumber("+0xF"), 572 "createNumber(String) LANG-1645a failed"); 573 assertEquals(Long.decode("+0xFFFFFFFF"), NumberUtils.createNumber("+0xFFFFFFFF"), 574 "createNumber(String) LANG-1645b failed"); 575 assertEquals(new BigInteger("+FFFFFFFFFFFFFFFF", 16), NumberUtils.createNumber("+0xFFFFFFFFFFFFFFFF"), 576 "createNumber(String) LANG-1645c failed"); 577 } 578 579 @Test 580 // Check that the code fails to create a valid number when preceded by -- rather than - testCreateNumberFailure_1()581 public void testCreateNumberFailure_1() { 582 assertThrows(NumberFormatException.class, () -> NumberUtils.createNumber("--1.1E-700F")); 583 } 584 585 @Test 586 // Check that the code fails to create a valid number when both e and E are present (with decimal) testCreateNumberFailure_2()587 public void testCreateNumberFailure_2() { 588 assertThrows(NumberFormatException.class, () -> NumberUtils.createNumber("-1.1E+0-7e00")); 589 } 590 591 @Test 592 // Check that the code fails to create a valid number when both e and E are present (no decimal) testCreateNumberFailure_3()593 public void testCreateNumberFailure_3() { 594 assertThrows(NumberFormatException.class, () -> NumberUtils.createNumber("-11E+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) testCreateNumberFailure_4()599 public void testCreateNumberFailure_4() { 600 assertThrows(NumberFormatException.class, () -> NumberUtils.createNumber("1eE+00001")); 601 } 602 603 @Test 604 // Check that the code fails to create a valid number when there are multiple trailing 'f' characters (LANG-1205) testCreateNumberFailure_5()605 public void testCreateNumberFailure_5() { 606 assertThrows(NumberFormatException.class, () -> NumberUtils.createNumber("1234.5ff")); 607 } 608 609 @Test 610 // Check that the code fails to create a valid number when there are multiple trailing 'F' characters (LANG-1205) testCreateNumberFailure_6()611 public void testCreateNumberFailure_6() { 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 'd' characters (LANG-1205) testCreateNumberFailure_7()617 public void testCreateNumberFailure_7() { 618 assertThrows(NumberFormatException.class, () -> NumberUtils.createNumber("1234.5dd")); 619 } 620 621 @Test 622 // Check that the code fails to create a valid number when there are multiple trailing 'D' characters (LANG-1205) testCreateNumberFailure_8()623 public void testCreateNumberFailure_8() { 624 assertThrows(NumberFormatException.class, () -> NumberUtils.createNumber("1234.5DD")); 625 } 626 627 // Tests to show when magnitude causes switch to next Number type 628 // Will probably need to be adjusted if code is changed to check precision (LANG-693) 629 @Test testCreateNumberMagnitude()630 public void testCreateNumberMagnitude() { 631 // Test Float.MAX_VALUE, and same with +1 in final digit to check conversion changes to next Number type 632 assertEquals(Float.valueOf(Float.MAX_VALUE), NumberUtils.createNumber("3.4028235e+38")); 633 assertEquals(Double.valueOf(3.4028236e+38), NumberUtils.createNumber("3.4028236e+38")); 634 635 // Test Double.MAX_VALUE 636 assertEquals(Double.valueOf(Double.MAX_VALUE), NumberUtils.createNumber("1.7976931348623157e+308")); 637 // Test with +2 in final digit (+1 does not cause roll-over to BigDecimal) 638 assertEquals(new BigDecimal("1.7976931348623159e+308"), NumberUtils.createNumber("1.7976931348623159e+308")); 639 640 // Requested type is parsed as zero but the value is not zero 641 final Double nonZero1 = Double.valueOf(((double) Float.MIN_VALUE) / 2); 642 assertEquals(nonZero1, NumberUtils.createNumber(nonZero1.toString())); 643 assertEquals(nonZero1, NumberUtils.createNumber(nonZero1.toString() + "F")); 644 // Smallest double is 4.9e-324. 645 // Test a number with zero before and/or after the decimal place to hit edge cases. 646 final BigDecimal nonZero2 = new BigDecimal("4.9e-325"); 647 assertEquals(nonZero2, NumberUtils.createNumber("4.9e-325")); 648 assertEquals(nonZero2, NumberUtils.createNumber("4.9e-325D")); 649 final BigDecimal nonZero3 = new BigDecimal("1e-325"); 650 assertEquals(nonZero3, NumberUtils.createNumber("1e-325")); 651 assertEquals(nonZero3, NumberUtils.createNumber("1e-325D")); 652 final BigDecimal nonZero4 = new BigDecimal("0.1e-325"); 653 assertEquals(nonZero4, NumberUtils.createNumber("0.1e-325")); 654 assertEquals(nonZero4, NumberUtils.createNumber("0.1e-325D")); 655 656 assertEquals(Integer.valueOf(0x12345678), NumberUtils.createNumber("0x12345678")); 657 assertEquals(Long.valueOf(0x123456789L), NumberUtils.createNumber("0x123456789")); 658 659 assertEquals(Long.valueOf(0x7fffffffffffffffL), NumberUtils.createNumber("0x7fffffffffffffff")); 660 // Does not appear to be a way to create a literal BigInteger of this magnitude 661 assertEquals(new BigInteger("7fffffffffffffff0", 16), NumberUtils.createNumber("0x7fffffffffffffff0")); 662 663 assertEquals(Long.valueOf(0x7fffffffffffffffL), NumberUtils.createNumber("#7fffffffffffffff")); 664 assertEquals(new BigInteger("7fffffffffffffff0", 16), NumberUtils.createNumber("#7fffffffffffffff0")); 665 666 assertEquals(Integer.valueOf(017777777777), NumberUtils.createNumber("017777777777")); // 31 bits 667 assertEquals(Long.valueOf(037777777777L), NumberUtils.createNumber("037777777777")); // 32 bits 668 669 // 63 bits 670 assertEquals(Long.valueOf(0777777777777777777777L), NumberUtils.createNumber("0777777777777777777777")); 671 // 64 bits 672 assertEquals(new BigInteger("1777777777777777777777", 8), NumberUtils.createNumber("01777777777777777777777")); 673 } 674 675 /** 676 * LANG-1646: Support the requested Number type (Long, Float, Double) of valid zero input. 677 */ 678 @Test testCreateNumberZero()679 public void testCreateNumberZero() { 680 // Handle integers 681 assertEquals(Integer.valueOf(0), NumberUtils.createNumber("0")); 682 assertEquals(Integer.valueOf(0), NumberUtils.createNumber("-0")); 683 assertEquals(Long.valueOf(0), NumberUtils.createNumber("0L")); 684 assertEquals(Long.valueOf(0), NumberUtils.createNumber("-0L")); 685 686 // Handle floating-point with optional leading sign, trailing exponent (eX) 687 // and format specifier (F or D). 688 // This should allow: 0. ; .0 ; 0.0 ; 0 (if exponent or format specifier is present) 689 690 // Exponent does not matter for zero 691 final int[] exponents = {-2345, 0, 13}; 692 final String[] zeros = {"0.", ".0", "0.0", "0"}; 693 final Float f0 = Float.valueOf(0); 694 final Float fn0 = Float.valueOf(-0F); 695 final Double d0 = Double.valueOf(0); 696 final Double dn0 = Double.valueOf(-0D); 697 698 for (final String zero : zeros) { 699 // Assume float if no preference. 700 // This requires a decimal point if there is no exponent. 701 if (zero.indexOf('.') != -1) { 702 assertCreateNumberZero(zero, f0, fn0); 703 } 704 for (final int exp : exponents) { 705 assertCreateNumberZero(zero + "e" + exp, f0, fn0); 706 } 707 // Type preference 708 assertCreateNumberZero(zero + "F", f0, fn0); 709 assertCreateNumberZero(zero + "D", d0, dn0); 710 for (final int exp : exponents) { 711 final String number = zero + "e" + exp; 712 assertCreateNumberZero(number + "F", f0, fn0); 713 assertCreateNumberZero(number + "D", d0, dn0); 714 } 715 } 716 } 717 assertCreateNumberZero(final String number, final Object zero, final Object negativeZero)718 private static void assertCreateNumberZero(final String number, final Object zero, final Object negativeZero) { 719 assertEquals(zero, NumberUtils.createNumber(number), () -> "Input: " + number); 720 assertEquals(zero, NumberUtils.createNumber("+" + number), () -> "Input: +" + number); 721 assertEquals(negativeZero, NumberUtils.createNumber("-" + number), () -> "Input: -" + number); 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 testIsCreatable()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 testIsDigits()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 testIsNumber()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 testIsNumberLANG1252()881 public void testIsNumberLANG1252() { 882 compareIsNumberWithCreateNumber("+2", true); 883 compareIsNumberWithCreateNumber("+2.0", true); 884 } 885 886 @Test testIsNumberLANG1385()887 public void testIsNumberLANG1385() { 888 compareIsNumberWithCreateNumber("L", false); 889 } 890 891 @Test testIsNumberLANG971()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 testIsNumberLANG972()901 public void testIsNumberLANG972() { 902 compareIsNumberWithCreateNumber("0xABCD", true); 903 compareIsNumberWithCreateNumber("0XABCD", true); 904 } 905 906 @Test testIsNumberLANG992()907 public void testIsNumberLANG992() { 908 compareIsNumberWithCreateNumber("0.0", true); 909 compareIsNumberWithCreateNumber("0.4790", true); 910 } 911 912 @Test testIsParsable()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 testLang1087()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 testLANG1252()949 public void testLANG1252() { 950 compareIsCreatableWithCreateNumber("+2", true); 951 compareIsCreatableWithCreateNumber("+2.0", true); 952 } 953 954 @Test testLang300()955 public void testLang300() { 956 NumberUtils.createNumber("-1l"); 957 NumberUtils.createNumber("01l"); 958 NumberUtils.createNumber("1l"); 959 } 960 961 @Test testLang381()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 TestLang747()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 testLANG971()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 testLANG972()1030 public void testLANG972() { 1031 compareIsCreatableWithCreateNumber("0xABCD", true); 1032 compareIsCreatableWithCreateNumber("0XABCD", true); 1033 } 1034 1035 @Test testLANG992()1036 public void testLANG992() { 1037 compareIsCreatableWithCreateNumber("0.0", true); 1038 compareIsCreatableWithCreateNumber("0.4790", true); 1039 } 1040 1041 @Test testMaxByte()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 testMaxByte_emptyArray()1052 public void testMaxByte_emptyArray() { 1053 assertThrows(IllegalArgumentException.class, NumberUtils::max); 1054 } 1055 1056 @Test testMaxByte_nullArray()1057 public void testMaxByte_nullArray() { 1058 assertThrows(NullPointerException.class, () -> NumberUtils.max((byte[]) null)); 1059 } 1060 1061 @Test testMaxDouble()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 testMaxDouble_emptyArray()1076 public void testMaxDouble_emptyArray() { 1077 assertThrows(IllegalArgumentException.class, NumberUtils::max); 1078 } 1079 1080 @Test testMaxDouble_nullArray()1081 public void testMaxDouble_nullArray() { 1082 assertThrows(NullPointerException.class, () -> NumberUtils.max((double[]) null)); 1083 } 1084 1085 @Test testMaxFloat()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 testMaxFloat_emptyArray()1095 public void testMaxFloat_emptyArray() { 1096 assertThrows(IllegalArgumentException.class, NumberUtils::max); 1097 } 1098 1099 @Test testMaxFloat_nullArray()1100 public void testMaxFloat_nullArray() { 1101 assertThrows(NullPointerException.class, () -> NumberUtils.max((float[]) null)); 1102 } 1103 1104 @Test testMaximumByte()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 testMaximumDouble()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 testMaximumFloat()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 testMaximumInt()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 testMaximumLong()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 testMaximumShort()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 testMaxInt()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 testMaxInt_emptyArray()1178 public void testMaxInt_emptyArray() { 1179 assertThrows(IllegalArgumentException.class, NumberUtils::max); 1180 } 1181 1182 @Test testMaxInt_nullArray()1183 public void testMaxInt_nullArray() { 1184 assertThrows(NullPointerException.class, () -> NumberUtils.max((int[]) null)); 1185 } 1186 1187 @Test testMaxLong()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 testMaxLong_emptyArray()1197 public void testMaxLong_emptyArray() { 1198 assertThrows(IllegalArgumentException.class, NumberUtils::max); 1199 } 1200 1201 @Test testMaxLong_nullArray()1202 public void testMaxLong_nullArray() { 1203 assertThrows(NullPointerException.class, () -> NumberUtils.max((long[]) null)); 1204 } 1205 1206 @Test testMaxShort()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 testMaxShort_emptyArray()1217 public void testMaxShort_emptyArray() { 1218 assertThrows(IllegalArgumentException.class, NumberUtils::max); 1219 } 1220 1221 @Test testMaxShort_nullArray()1222 public void testMaxShort_nullArray() { 1223 assertThrows(NullPointerException.class, () -> NumberUtils.max((short[]) null)); 1224 } 1225 1226 @Test testMinByte()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 testMinByte_emptyArray()1236 public void testMinByte_emptyArray() { 1237 assertThrows(IllegalArgumentException.class, NumberUtils::min); 1238 } 1239 1240 @Test testMinByte_nullArray()1241 public void testMinByte_nullArray() { 1242 assertThrows(NullPointerException.class, () -> NumberUtils.min((byte[]) null)); 1243 } 1244 1245 @Test testMinDouble()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 testMinDouble_emptyArray()1256 public void testMinDouble_emptyArray() { 1257 assertThrows(IllegalArgumentException.class, NumberUtils::min); 1258 } 1259 1260 @Test testMinDouble_nullArray()1261 public void testMinDouble_nullArray() { 1262 assertThrows(NullPointerException.class, () -> NumberUtils.min((double[]) null)); 1263 } 1264 1265 @Test testMinFloat()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 testMinFloat_emptyArray()1277 public void testMinFloat_emptyArray() { 1278 assertThrows(IllegalArgumentException.class, NumberUtils::min); 1279 } 1280 1281 @Test testMinFloat_nullArray()1282 public void testMinFloat_nullArray() { 1283 assertThrows(NullPointerException.class, () -> NumberUtils.min((float[]) null)); 1284 } 1285 1286 @Test testMinimumByte()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 testMinimumDouble()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 testMinimumFloat()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 testMinimumInt()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 testMinimumLong()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 testMinimumShort()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 testMinInt()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 testMinInt_emptyArray()1360 public void testMinInt_emptyArray() { 1361 assertThrows(IllegalArgumentException.class, NumberUtils::min); 1362 } 1363 1364 @Test testMinInt_nullArray()1365 public void testMinInt_nullArray() { 1366 assertThrows(NullPointerException.class, () -> NumberUtils.min((int[]) null)); 1367 } 1368 1369 @Test testMinLong()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 testMinLong_emptyArray()1379 public void testMinLong_emptyArray() { 1380 assertThrows(IllegalArgumentException.class, NumberUtils::min); 1381 } 1382 1383 @Test testMinLong_nullArray()1384 public void testMinLong_nullArray() { 1385 assertThrows(NullPointerException.class, () -> NumberUtils.min((long[]) null)); 1386 } 1387 1388 @Test testMinShort()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 testMinShort_emptyArray()1398 public void testMinShort_emptyArray() { 1399 assertThrows(IllegalArgumentException.class, NumberUtils::min); 1400 } 1401 1402 @Test testMinShort_nullArray()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 testStringCreateNumberEnsureNoPrecisionLoss()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 testStringToDoubleString()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 testStringToDoubleStringD()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 testToByteString()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 testToByteStringI()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 testToFloatString()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 testToFloatStringF()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 testToIntString()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 testToIntStringI()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 testToLongString()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 testToLongStringL()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 testToScaledBigDecimalBigDecimal()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 testToScaledBigDecimalBigDecimalIRM()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 testToScaledBigDecimalDouble()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 testToScaledBigDecimalDoubleIRM()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 testToScaledBigDecimalFloat()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 testToScaledBigDecimalFloatIRM()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 testToScaledBigDecimalString()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 testToScaledBigDecimalStringIRM()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 testToShortString()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 testToShortStringI()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 } 1747