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 18package libcore.java.lang; 19 20import junit.framework.Assert; 21import junit.framework.TestCase; 22 23public class OldAndroidMathTest extends TestCase { 24 25 private static final double HYP = Math.sqrt(2.0); 26 27 private static final double OPP = 1.0; 28 29 private static final double ADJ = 1.0; 30 31 /* Required to make previous preprocessor flags work - do not remove */ 32 int unused = 0; 33 34 public static void assertEquals(String message, double expected, double actual, double delta) { 35 if (delta == 0D) { 36 Assert.assertEquals(message, expected, actual, Math.ulp(expected)); 37 } else { 38 Assert.assertEquals(message, expected, actual, delta); 39 } 40 } 41 42 public static void assertEquals(String message, float expected, float actual, float delta) { 43 if (delta == 0F) { 44 Assert.assertEquals(message, expected, actual, Math.ulp(expected)); 45 } else { 46 Assert.assertEquals(message, expected, actual, delta); 47 } 48 } 49 50 public void testAbsD() { 51 // Test for method double java.lang.Math.abs(double) 52 53 assertTrue("Incorrect double abs value", 54 (Math.abs(-1908.8976) == 1908.8976)); 55 assertTrue("Incorrect double abs value", 56 (Math.abs(1908.8976) == 1908.8976)); 57 } 58 59 public void testAbsF() { 60 // Test for method float java.lang.Math.abs(float) 61 assertTrue("Incorrect float abs value", 62 (Math.abs(-1908.8976f) == 1908.8976f)); 63 assertTrue("Incorrect float abs value", 64 (Math.abs(1908.8976f) == 1908.8976f)); 65 } 66 67 public void testAbsI() { 68 // Test for method int java.lang.Math.abs(int) 69 assertTrue("Incorrect int abs value", (Math.abs(-1908897) == 1908897)); 70 assertTrue("Incorrect int abs value", (Math.abs(1908897) == 1908897)); 71 } 72 73 public void testAbsJ() { 74 // Test for method long java.lang.Math.abs(long) 75 assertTrue("Incorrect long abs value", 76 (Math.abs(-19088976000089L) == 19088976000089L)); 77 assertTrue("Incorrect long abs value", 78 (Math.abs(19088976000089L) == 19088976000089L)); 79 } 80 81 public void testAcosD() { 82 // Test for method double java.lang.Math.acos(double) 83 double r = Math.cos(Math.acos(ADJ / HYP)); 84 long lr = Double.doubleToLongBits(r); 85 long t = Double.doubleToLongBits(ADJ / HYP); 86 assertTrue("Returned incorrect arc cosine", lr == t || (lr + 1) == t 87 || (lr - 1) == t); 88 } 89 90 public void testAsinD() { 91 // Test for method double java.lang.Math.asin(double) 92 double r = Math.sin(Math.asin(OPP / HYP)); 93 long lr = Double.doubleToLongBits(r); 94 long t = Double.doubleToLongBits(OPP / HYP); 95 assertTrue("Returned incorrect arc sine", lr == t || (lr + 1) == t 96 || (lr - 1) == t); 97 } 98 99 public void testAtanD() { 100 // Test for method double java.lang.Math.atan(double) 101 double answer = Math.tan(Math.atan(1.0)); 102 assertTrue("Returned incorrect arc tangent: " + answer, answer <= 1.0 103 && answer >= 9.9999999999999983E-1); 104 } 105 106 public void testAtan2DD() { 107 // Test for method double java.lang.Math.atan2(double, double) 108 double answer = Math.atan(Math.tan(1.0)); 109 assertTrue("Returned incorrect arc tangent: " + answer, answer <= 1.0 110 && answer >= 9.9999999999999983E-1); 111 } 112 113 public void testCbrtD() { 114 //Test for special situations 115 assertTrue("Should return Double.NaN", Double.isNaN(Math 116 .cbrt(Double.NaN))); 117 assertEquals("Should return Double.POSITIVE_INFINITY", 118 Double.POSITIVE_INFINITY, Math 119 .cbrt(Double.POSITIVE_INFINITY), 0D); 120 assertEquals("Should return Double.NEGATIVE_INFINITY", 121 Double.NEGATIVE_INFINITY, Math 122 .cbrt(Double.NEGATIVE_INFINITY), 0D); 123 assertEquals(Double.doubleToLongBits(0.0), Double.doubleToLongBits(Math 124 .cbrt(0.0))); 125 assertEquals(Double.doubleToLongBits(+0.0), Double.doubleToLongBits(Math 126 .cbrt(+0.0))); 127 assertEquals(Double.doubleToLongBits(-0.0), Double.doubleToLongBits(Math 128 .cbrt(-0.0))); 129 130 assertEquals("Should return 3.0", 3.0, Math.cbrt(27.0), 0D); 131 assertEquals("Should return 23.111993172558684", 23.111993172558684, 132 Math.cbrt(12345.6), 0D); 133 assertEquals("Should return 5.643803094122362E102", 134 5.643803094122362E102, Math.cbrt(Double.MAX_VALUE), 0D); 135 assertEquals("Should return 0.01", 0.01, Math.cbrt(0.000001), 0D); 136 137 assertEquals("Should return -3.0", -3.0, Math.cbrt(-27.0), 0D); 138 assertEquals("Should return -23.111993172558684", -23.111993172558684, 139 Math.cbrt(-12345.6), 0D); 140 assertEquals("Should return 1.7031839360032603E-108", 141 1.7031839360032603E-108, Math.cbrt(Double.MIN_VALUE), 0D); 142 assertEquals("Should return -0.01", -0.01, Math.cbrt(-0.000001), 0D); 143 } 144 145 public void testCeilD() { 146 // Test for method double java.lang.Math.ceil(double) 147 assertEquals("Incorrect ceiling for double", 148 79, Math.ceil(78.89), 0); 149 assertEquals("Incorrect ceiling for double", 150 -78, Math.ceil(-78.89), 0); 151 } 152 153 public void testCosD() { 154 // Test for method double java.lang.Math.cos(double) 155 assertEquals("Incorrect answer", 1.0, Math.cos(0), 0D); 156 assertEquals("Incorrect answer", 0.5403023058681398, Math.cos(1), 0D); 157 } 158 159 public void testCoshD() { 160 // Test for special situations 161 assertTrue(Double.isNaN(Math.cosh(Double.NaN))); 162 assertEquals("Should return POSITIVE_INFINITY", 163 Double.POSITIVE_INFINITY, Math.cosh(Double.POSITIVE_INFINITY), 0D); 164 assertEquals("Should return POSITIVE_INFINITY", 165 Double.POSITIVE_INFINITY, Math.cosh(Double.NEGATIVE_INFINITY), 0D); 166 assertEquals("Should return 1.0", 1.0, Math.cosh(+0.0), 0D); 167 assertEquals("Should return 1.0", 1.0, Math.cosh(-0.0), 0D); 168 169 assertEquals("Should return POSITIVE_INFINITY", 170 Double.POSITIVE_INFINITY, Math.cosh(1234.56), 0D); 171 assertEquals("Should return POSITIVE_INFINITY", 172 Double.POSITIVE_INFINITY, Math.cosh(-1234.56), 0D); 173 assertEquals("Should return 1.0000000000005", 1.0000000000005, Math 174 .cosh(0.000001), 0D); 175 assertEquals("Should return 1.0000000000005", 1.0000000000005, Math 176 .cosh(-0.000001), 0D); 177 assertEquals("Should return 5.212214351945598", 5.212214351945598, Math 178 .cosh(2.33482), 0D); 179 180 assertEquals("Should return POSITIVE_INFINITY", 181 Double.POSITIVE_INFINITY, Math.cosh(Double.MAX_VALUE), 0D); 182 assertEquals("Should return 1.0", 1.0, Math.cosh(Double.MIN_VALUE), 0D); 183 } 184 185 public void testExpD() { 186 // Test for method double java.lang.Math.exp(double) 187 assertTrue("Incorrect answer returned for simple power", Math.abs(Math 188 .exp(4D) 189 - Math.E * Math.E * Math.E * Math.E) < 0.1D); 190 assertTrue("Incorrect answer returned for larger power", Math.log(Math 191 .abs(Math.exp(5.5D)) - 5.5D) < 10.0D); 192 } 193 194 public void testExpm1D() { 195 // Test for special cases 196 assertTrue("Should return NaN", Double.isNaN(Math.expm1(Double.NaN))); 197 assertEquals("Should return POSITIVE_INFINITY", 198 Double.POSITIVE_INFINITY, Math.expm1(Double.POSITIVE_INFINITY), 0D); 199 assertEquals("Should return -1.0", -1.0, Math 200 .expm1(Double.NEGATIVE_INFINITY), 0D); 201 assertEquals(Double.doubleToLongBits(0.0), Double.doubleToLongBits(Math 202 .expm1(0.0))); 203 assertEquals(Double.doubleToLongBits(+0.0), Double 204 .doubleToLongBits(Math.expm1(+0.0))); 205 assertEquals(Double.doubleToLongBits(-0.0), Double 206 .doubleToLongBits(Math.expm1(-0.0))); 207 208 assertEquals("Should return -9.999950000166666E-6", 209 -9.999950000166666E-6, Math.expm1(-0.00001), 0D); 210 assertEquals("Should return 1.0145103074469635E60", 211 1.0145103074469635E60, Math.expm1(138.16951162), 0D); 212 assertEquals("Should return POSITIVE_INFINITY", 213 Double.POSITIVE_INFINITY, Math 214 .expm1(123456789123456789123456789.4521584223), 0D); 215 assertEquals("Should return POSITIVE_INFINITY", 216 Double.POSITIVE_INFINITY, Math.expm1(Double.MAX_VALUE), 0D); 217 assertEquals("Should return MIN_VALUE", Double.MIN_VALUE, Math 218 .expm1(Double.MIN_VALUE), 0D); 219 } 220 221 public void testFloorD() { 222 // Test for method double java.lang.Math.floor(double) 223 assertEquals("Incorrect floor for double", 224 78, Math.floor(78.89), 0); 225 assertEquals("Incorrect floor for double", 226 -79, Math.floor(-78.89), 0); 227 } 228 229 public void testHypotDD() { 230 // Test for special cases 231 assertEquals("Should return POSITIVE_INFINITY", 232 Double.POSITIVE_INFINITY, Math.hypot(Double.POSITIVE_INFINITY, 233 1.0), 0D); 234 assertEquals("Should return POSITIVE_INFINITY", 235 Double.POSITIVE_INFINITY, Math.hypot(Double.NEGATIVE_INFINITY, 236 123.324), 0D); 237 assertEquals("Should return POSITIVE_INFINITY", 238 Double.POSITIVE_INFINITY, Math.hypot(-758.2587, 239 Double.POSITIVE_INFINITY), 0D); 240 assertEquals("Should return POSITIVE_INFINITY", 241 Double.POSITIVE_INFINITY, Math.hypot(5687.21, 242 Double.NEGATIVE_INFINITY), 0D); 243 assertEquals("Should return POSITIVE_INFINITY", 244 Double.POSITIVE_INFINITY, Math.hypot(Double.POSITIVE_INFINITY, 245 Double.NEGATIVE_INFINITY), 0D); 246 assertEquals("Should return POSITIVE_INFINITY", 247 Double.POSITIVE_INFINITY, Math.hypot(Double.NEGATIVE_INFINITY, 248 Double.POSITIVE_INFINITY), 0D); 249 assertTrue("Should be NaN", Double.isNaN(Math.hypot(Double.NaN, 250 2342301.89843))); 251 assertTrue("Should be NaN", Double.isNaN(Math.hypot(-345.2680, 252 Double.NaN))); 253 254 assertEquals("Should return 2396424.905416697", 2396424.905416697, Math 255 .hypot(12322.12, -2396393.2258), 0D); 256 assertEquals("Should return 138.16958070558556", 138.16958070558556, 257 Math.hypot(-138.16951162, 0.13817035864), 0D); 258 assertEquals("Should return 1.7976931348623157E308", 259 1.7976931348623157E308, Math.hypot(Double.MAX_VALUE, 211370.35), 0D); 260 assertEquals("Should return 5413.7185", 5413.7185, Math.hypot( 261 -5413.7185, Double.MIN_VALUE), 0D); 262 } 263 264 public void testIEEEremainderDD() { 265 // Test for method double java.lang.Math.IEEEremainder(double, double) 266 assertEquals("Incorrect remainder returned", 267 0.0, Math.IEEEremainder(1.0, 1.0), 0D); 268 assertTrue("Incorrect remainder returned", Math.IEEEremainder(1.32, 269 89.765) >= 1.4705063220631647E-2 270 || Math.IEEEremainder(1.32, 89.765) >= 1.4705063220631649E-2); 271 } 272 273 public void testLogD() { 274 // Test for method double java.lang.Math.log(double) 275 for (double d = 10; d >= -10; d -= 0.5) { 276 double answer = Math.log(Math.exp(d)); 277 assertTrue("Answer does not equal expected answer for d = " + d 278 + " answer = " + answer, Math.abs(answer - d) <= Math 279 .abs(d * 0.00000001)); 280 } 281 } 282 283 @SuppressWarnings("boxing") 284 public void testLog10D() { 285 // Test for special cases 286 assertTrue(Double.isNaN(Math.log10(Double.NaN))); 287 assertTrue(Double.isNaN(Math.log10(-2541.05745687234187532))); 288 assertTrue(Double.isNaN(Math.log10(-0.1))); 289 assertEquals(Double.POSITIVE_INFINITY, Math.log10(Double.POSITIVE_INFINITY)); 290 assertEquals(Double.NEGATIVE_INFINITY, Math.log10(0.0)); 291 assertEquals(Double.NEGATIVE_INFINITY, Math.log10(+0.0)); 292 assertEquals(Double.NEGATIVE_INFINITY, Math.log10(-0.0)); 293 294 assertEquals(3.0, Math.log10(1000.0)); 295 assertEquals(14.0, Math.log10(Math.pow(10, 14))); 296 assertEquals(3.7389561269540406, Math.log10(5482.2158)); 297 assertEquals(14.661551142893833, Math.log10(458723662312872.125782332587)); 298 assertEquals(-0.9083828622192334, Math.log10(0.12348583358871)); 299 assertEquals(308.25471555991675, Math.log10(Double.MAX_VALUE)); 300 assertEquals(-323.3062153431158, Math.log10(Double.MIN_VALUE)); 301 } 302 303 public void testLog1pD() { 304 // Test for special cases 305 assertTrue("Should return NaN", Double.isNaN(Math.log1p(Double.NaN))); 306 assertTrue("Should return NaN", Double.isNaN(Math.log1p(-32.0482175))); 307 assertEquals("Should return POSITIVE_INFINITY", 308 Double.POSITIVE_INFINITY, Math.log1p(Double.POSITIVE_INFINITY), 0D); 309 assertEquals(Double.doubleToLongBits(0.0), Double.doubleToLongBits(Math 310 .log1p(0.0))); 311 assertEquals(Double.doubleToLongBits(+0.0), Double 312 .doubleToLongBits(Math.log1p(+0.0))); 313 assertEquals(Double.doubleToLongBits(-0.0), Double 314 .doubleToLongBits(Math.log1p(-0.0))); 315 316 assertEquals("Should return -0.2941782295312541", -0.2941782295312541, 317 Math.log1p(-0.254856327), 0D); 318 assertEquals("Should return 7.368050685564151", 7.368050685564151, Math 319 .log1p(1583.542), 0D); 320 assertEquals("Should return 0.4633708685409921", 0.4633708685409921, 321 Math.log1p(0.5894227), 0D); 322 assertEquals("Should return 709.782712893384", 709.782712893384, Math 323 .log1p(Double.MAX_VALUE), 0D); 324 assertEquals("Should return Double.MIN_VALUE", Double.MIN_VALUE, Math 325 .log1p(Double.MIN_VALUE), 0D); 326 } 327 328 public void testMaxDD() { 329 // Test for method double java.lang.Math.max(double, double) 330 assertEquals("Incorrect double max value", 1908897.6000089, Math.max(-1908897.6000089, 331 1908897.6000089), 0D); 332 assertEquals("Incorrect double max value", 333 1908897.6000089, Math.max(2.0, 1908897.6000089), 0D); 334 assertEquals("Incorrect double max value", -2.0, Math.max(-2.0, 335 -1908897.6000089), 0D); 336 337 } 338 339 public void testMaxFF() { 340 // Test for method float java.lang.Math.max(float, float) 341 assertTrue("Incorrect float max value", Math.max(-1908897.600f, 342 1908897.600f) == 1908897.600f); 343 assertTrue("Incorrect float max value", 344 Math.max(2.0f, 1908897.600f) == 1908897.600f); 345 assertTrue("Incorrect float max value", 346 Math.max(-2.0f, -1908897.600f) == -2.0f); 347 } 348 349 public void testMaxII() { 350 // Test for method int java.lang.Math.max(int, int) 351 assertEquals("Incorrect int max value", 352 19088976, Math.max(-19088976, 19088976)); 353 assertEquals("Incorrect int max value", 354 19088976, Math.max(20, 19088976)); 355 assertEquals("Incorrect int max value", -20, Math.max(-20, -19088976)); 356 } 357 358 public void testMaxJJ() { 359 // Test for method long java.lang.Math.max(long, long) 360 assertEquals("Incorrect long max value", 19088976000089L, Math.max(-19088976000089L, 361 19088976000089L)); 362 assertEquals("Incorrect long max value", 363 19088976000089L, Math.max(20, 19088976000089L)); 364 assertEquals("Incorrect long max value", 365 -20, Math.max(-20, -19088976000089L)); 366 } 367 368 public void testMinDD() { 369 // Test for method double java.lang.Math.min(double, double) 370 assertEquals("Incorrect double min value", -1908897.6000089, Math.min(-1908897.6000089, 371 1908897.6000089), 0D); 372 assertEquals("Incorrect double min value", 373 2.0, Math.min(2.0, 1908897.6000089), 0D); 374 assertEquals("Incorrect double min value", -1908897.6000089, Math.min(-2.0, 375 -1908897.6000089), 0D); 376 } 377 378 public void testMinFF() { 379 // Test for method float java.lang.Math.min(float, float) 380 assertTrue("Incorrect float min value", Math.min(-1908897.600f, 381 1908897.600f) == -1908897.600f); 382 assertTrue("Incorrect float min value", 383 Math.min(2.0f, 1908897.600f) == 2.0f); 384 assertTrue("Incorrect float min value", 385 Math.min(-2.0f, -1908897.600f) == -1908897.600f); 386 } 387 388 public void testMinII() { 389 // Test for method int java.lang.Math.min(int, int) 390 assertEquals("Incorrect int min value", 391 -19088976, Math.min(-19088976, 19088976)); 392 assertEquals("Incorrect int min value", 20, Math.min(20, 19088976)); 393 assertEquals("Incorrect int min value", 394 -19088976, Math.min(-20, -19088976)); 395 396 } 397 398 public void testMinJJ() { 399 // Test for method long java.lang.Math.min(long, long) 400 assertEquals("Incorrect long min value", -19088976000089L, Math.min(-19088976000089L, 401 19088976000089L)); 402 assertEquals("Incorrect long min value", 403 20, Math.min(20, 19088976000089L)); 404 assertEquals("Incorrect long min value", 405 -19088976000089L, Math.min(-20, -19088976000089L)); 406 } 407 408 public void testPowDD() { 409 // Test for method double java.lang.Math.pow(double, double) 410 assertTrue("pow returned incorrect value", 411 (long) Math.pow(2, 8) == 256l); 412 assertTrue("pow returned incorrect value", 413 Math.pow(2, -8) == 0.00390625d); 414 assertEquals("Incorrect root returned1", 415 2, Math.sqrt(Math.pow(Math.sqrt(2), 4)), 0); 416 } 417 418 public void testRintD() { 419 // Test for method double java.lang.Math.rint(double) 420 assertEquals("Failed to round properly - up to odd", 421 3.0, Math.rint(2.9), 0D); 422 assertTrue("Failed to round properly - NaN", Double.isNaN(Math 423 .rint(Double.NaN))); 424 assertEquals("Failed to round properly down to even", 425 2.0, Math.rint(2.1), 0D); 426 assertTrue("Failed to round properly " + 2.5 + " to even", Math 427 .rint(2.5) == 2.0); 428 } 429 430 public void testRoundD() { 431 // Test for method long java.lang.Math.round(double) 432 assertEquals("Incorrect rounding of a float", -91, Math.round(-90.89d)); 433 } 434 435 public void testRoundF() { 436 // Test for method int java.lang.Math.round(float) 437 assertEquals("Incorrect rounding of a float", -91, Math.round(-90.89f)); 438 } 439 440 public void testSignumD() { 441 assertTrue(Double.isNaN(Math.signum(Double.NaN))); 442 assertTrue(Double.isNaN(Math.signum(Double.NaN))); 443 assertEquals(Double.doubleToLongBits(0.0), Double.doubleToLongBits(Math 444 .signum(0.0))); 445 assertEquals(Double.doubleToLongBits(+0.0), Double 446 .doubleToLongBits(Math.signum(+0.0))); 447 assertEquals(Double.doubleToLongBits(-0.0), Double 448 .doubleToLongBits(Math.signum(-0.0))); 449 450 assertEquals(1.0, Math.signum(253681.2187962), 0D); 451 assertEquals(-1.0, Math.signum(-125874693.56), 0D); 452 assertEquals(1.0, Math.signum(1.2587E-308), 0D); 453 assertEquals(-1.0, Math.signum(-1.2587E-308), 0D); 454 455 assertEquals(1.0, Math.signum(Double.MAX_VALUE), 0D); 456 assertEquals(1.0, Math.signum(Double.MIN_VALUE), 0D); 457 assertEquals(-1.0, Math.signum(-Double.MAX_VALUE), 0D); 458 assertEquals(-1.0, Math.signum(-Double.MIN_VALUE), 0D); 459 assertEquals(1.0, Math.signum(Double.POSITIVE_INFINITY), 0D); 460 assertEquals(-1.0, Math.signum(Double.NEGATIVE_INFINITY), 0D); 461 } 462 463 public void testSignumF() { 464 assertTrue(Float.isNaN(Math.signum(Float.NaN))); 465 assertEquals(Float.floatToIntBits(0.0f), Float 466 .floatToIntBits(Math.signum(0.0f))); 467 assertEquals(Float.floatToIntBits(+0.0f), Float 468 .floatToIntBits(Math.signum(+0.0f))); 469 assertEquals(Float.floatToIntBits(-0.0f), Float 470 .floatToIntBits(Math.signum(-0.0f))); 471 472 assertEquals(1.0f, Math.signum(253681.2187962f), 0f); 473 assertEquals(-1.0f, Math.signum(-125874693.56f), 0f); 474 assertEquals(1.0f, Math.signum(1.2587E-11f), 0f); 475 assertEquals(-1.0f, Math.signum(-1.2587E-11f), 0f); 476 477 assertEquals(1.0f, Math.signum(Float.MAX_VALUE), 0f); 478 assertEquals(1.0f, Math.signum(Float.MIN_VALUE), 0f); 479 assertEquals(-1.0f, Math.signum(-Float.MAX_VALUE), 0f); 480 assertEquals(-1.0f, Math.signum(-Float.MIN_VALUE), 0f); 481 assertEquals(1.0f, Math.signum(Float.POSITIVE_INFINITY), 0f); 482 assertEquals(-1.0f, Math.signum(Float.NEGATIVE_INFINITY), 0f); 483 } 484 485 public void testSinD() { 486 // Test for method double java.lang.Math.sin(double) 487 assertEquals("Incorrect answer", 0.0, Math.sin(0), 0D); 488 assertEquals("Incorrect answer", 0.8414709848078965, Math.sin(1), 0D); 489 } 490 491 public void testSinhD() { 492 // Test for special situations 493 assertTrue("Should return NaN", Double.isNaN(Math.sinh(Double.NaN))); 494 assertEquals("Should return POSITIVE_INFINITY", 495 Double.POSITIVE_INFINITY, Math.sinh(Double.POSITIVE_INFINITY), 0D); 496 assertEquals("Should return NEGATIVE_INFINITY", 497 Double.NEGATIVE_INFINITY, Math.sinh(Double.NEGATIVE_INFINITY), 0D); 498 assertEquals(Double.doubleToLongBits(0.0), Double.doubleToLongBits(Math 499 .sinh(0.0))); 500 assertEquals(Double.doubleToLongBits(+0.0), Double 501 .doubleToLongBits(Math.sinh(+0.0))); 502 assertEquals(Double.doubleToLongBits(-0.0), Double 503 .doubleToLongBits(Math.sinh(-0.0))); 504 505 assertEquals("Should return POSITIVE_INFINITY", 506 Double.POSITIVE_INFINITY, Math.sinh(1234.56), 0D); 507 assertEquals("Should return NEGATIVE_INFINITY", 508 Double.NEGATIVE_INFINITY, Math.sinh(-1234.56), 0D); 509 assertEquals("Should return 1.0000000000001666E-6", 510 1.0000000000001666E-6, Math.sinh(0.000001), 0D); 511 assertEquals("Should return -1.0000000000001666E-6", 512 -1.0000000000001666E-6, Math.sinh(-0.000001), 0D); 513 assertEquals("Should return 5.115386441963859", 5.115386441963859, Math 514 .sinh(2.33482), 0D); 515 assertEquals("Should return POSITIVE_INFINITY", 516 Double.POSITIVE_INFINITY, Math.sinh(Double.MAX_VALUE), 0D); 517 assertEquals("Should return 4.9E-324", 4.9E-324, Math 518 .sinh(Double.MIN_VALUE), 0D); 519 } 520 521 public void testSqrtD() { 522 // Test for method double java.lang.Math.sqrt(double) 523 assertEquals("Incorrect root returned2", 7, Math.sqrt(49), 0); 524 } 525 526 public void testTanD() { 527 // Test for method double java.lang.Math.tan(double) 528 assertEquals("Incorrect answer", 0.0, Math.tan(0), 0D); 529 assertEquals("Incorrect answer", 1.5574077246549023, Math.tan(1), 0D); 530 531 } 532 533 public void testTanhD() { 534 // Test for special situations 535 assertTrue("Should return NaN", Double.isNaN(Math.tanh(Double.NaN))); 536 assertEquals("Should return +1.0", +1.0, Math 537 .tanh(Double.POSITIVE_INFINITY), 0D); 538 assertEquals("Should return -1.0", -1.0, Math 539 .tanh(Double.NEGATIVE_INFINITY), 0D); 540 assertEquals(Double.doubleToLongBits(0.0), Double.doubleToLongBits(Math 541 .tanh(0.0))); 542 assertEquals(Double.doubleToLongBits(+0.0), Double 543 .doubleToLongBits(Math.tanh(+0.0))); 544 assertEquals(Double.doubleToLongBits(-0.0), Double 545 .doubleToLongBits(Math.tanh(-0.0))); 546 547 assertEquals("Should return 1.0", 1.0, Math.tanh(1234.56), 0D); 548 assertEquals("Should return -1.0", -1.0, Math.tanh(-1234.56), 0D); 549 assertEquals("Should return 9.999999999996666E-7", 550 9.999999999996666E-7, Math.tanh(0.000001), 0D); 551 assertEquals("Should return 0.981422884124941", 0.981422884124941, Math 552 .tanh(2.33482), 0D); 553 assertEquals("Should return 1.0", 1.0, Math.tanh(Double.MAX_VALUE), 0D); 554 assertEquals("Should return 4.9E-324", 4.9E-324, Math 555 .tanh(Double.MIN_VALUE), 0D); 556 } 557 558 public void testRandom() { 559 // There isn't a place for these tests so just stick them here 560 assertEquals("Wrong value E", 561 4613303445314885481L, Double.doubleToLongBits(Math.E)); 562 assertEquals("Wrong value PI", 563 4614256656552045848L, Double.doubleToLongBits(Math.PI)); 564 565 for (int i = 500; i >= 0; i--) { 566 double d = Math.random(); 567 assertTrue("Generated number is out of range: " + d, d >= 0.0 568 && d < 1.0); 569 } 570 } 571 572 public void testToRadiansD() { 573 for (double d = 500; d >= 0; d -= 1.0) { 574 double converted = Math.toDegrees(Math.toRadians(d)); 575 assertTrue("Converted number not equal to original. d = " + d, 576 converted >= d * 0.99999999 && converted <= d * 1.00000001); 577 } 578 } 579 580 public void testToDegreesD() { 581 for (double d = 500; d >= 0; d -= 1.0) { 582 double converted = Math.toRadians(Math.toDegrees(d)); 583 assertTrue("Converted number not equal to original. d = " + d, 584 converted >= d * 0.99999999 && converted <= d * 1.00000001); 585 } 586 } 587 588 @SuppressWarnings("boxing") 589 public void testUlpD() { 590 // Test for special cases 591 assertTrue("Should return NaN", Double.isNaN(Math.ulp(Double.NaN))); 592 assertEquals("Returned incorrect value", Double.POSITIVE_INFINITY, Math 593 .ulp(Double.POSITIVE_INFINITY), 0D); 594 assertEquals("Returned incorrect value", Double.POSITIVE_INFINITY, Math 595 .ulp(Double.NEGATIVE_INFINITY), 0D); 596 assertEquals("Returned incorrect value", Double.MIN_VALUE, Math 597 .ulp(0.0), 0D); 598 assertEquals("Returned incorrect value", Double.MIN_VALUE, Math 599 .ulp(+0.0), 0D); 600 assertEquals("Returned incorrect value", Double.MIN_VALUE, Math 601 .ulp(-0.0), 0D); 602 assertEquals("Returned incorrect value", Math.pow(2, 971), Math 603 .ulp(Double.MAX_VALUE), 0D); 604 assertEquals("Returned incorrect value", Math.pow(2, 971), Math 605 .ulp(-Double.MAX_VALUE), 0D); 606 607 assertEquals("Returned incorrect value", Double.MIN_VALUE, Math 608 .ulp(Double.MIN_VALUE), 0D); 609 assertEquals("Returned incorrect value", Double.MIN_VALUE, Math 610 .ulp(-Double.MIN_VALUE), 0D); 611 612 assertEquals("Returned incorrect value", 2.220446049250313E-16, Math 613 .ulp(1.0), 0D); 614 assertEquals("Returned incorrect value", 2.220446049250313E-16, Math 615 .ulp(-1.0), 0D); 616 assertEquals("Returned incorrect value", 2.2737367544323206E-13, Math 617 .ulp(1153.0), 0D); 618 } 619 620 @SuppressWarnings("boxing") 621 public void testUlpf() { 622 // Test for special cases 623 assertTrue("Should return NaN", Float.isNaN(Math.ulp(Float.NaN))); 624 assertEquals("Returned incorrect value", Float.POSITIVE_INFINITY, Math 625 .ulp(Float.POSITIVE_INFINITY), 0f); 626 assertEquals("Returned incorrect value", Float.POSITIVE_INFINITY, Math 627 .ulp(Float.NEGATIVE_INFINITY), 0f); 628 assertEquals("Returned incorrect value", Float.MIN_VALUE, Math 629 .ulp(0.0f), 0f); 630 assertEquals("Returned incorrect value", Float.MIN_VALUE, Math 631 .ulp(+0.0f), 0f); 632 assertEquals("Returned incorrect value", Float.MIN_VALUE, Math 633 .ulp(-0.0f), 0f); 634 assertEquals("Returned incorrect value", 2.028241E31f, Math 635 .ulp(Float.MAX_VALUE), 0f); 636 assertEquals("Returned incorrect value", 2.028241E31f, Math 637 .ulp(-Float.MAX_VALUE), 0f); 638 639 assertEquals("Returned incorrect value", 1.4E-45f, Math 640 .ulp(Float.MIN_VALUE), 0f); 641 assertEquals("Returned incorrect value", 1.4E-45f, Math 642 .ulp(-Float.MIN_VALUE), 0f); 643 644 assertEquals("Returned incorrect value", 1.1920929E-7f, Math.ulp(1.0f), 645 0f); 646 assertEquals("Returned incorrect value", 1.1920929E-7f, 647 Math.ulp(-1.0f), 0f); 648 assertEquals("Returned incorrect value", 1.2207031E-4f, Math 649 .ulp(1153.0f), 0f); 650 assertEquals("Returned incorrect value", 5.6E-45f, Math 651 .ulp(9.403954E-38f), 0f); 652 } 653} 654