test/java/lang/Math/HyperbolicTests.java

*** 23,36 ****
  
  /*
   * @test
   * @bug 4851625 4900189 4939441
   * @summary Tests for {Math, StrictMath}.{sinh, cosh, tanh}
   * @author Joseph D. Darcy
   */
  
! import sun.misc.DoubleConsts;
  
  public class HyperbolicTests {
      private HyperbolicTests(){}
  
      static final double NaNd = Double.NaN;
--- 23,39 ----
  
  /*
   * @test
   * @bug 4851625 4900189 4939441
   * @summary Tests for {Math, StrictMath}.{sinh, cosh, tanh}
+  * @library /lib/testlibrary
+  * @build jdk.testlibrary.DoubleUtils jdk.testlibrary.FloatUtils
+  * @run main HyperbolicTests
   * @author Joseph D. Darcy
   */
  
! import static jdk.testlibrary.DoubleUtils.*;
  
  public class HyperbolicTests {
      private HyperbolicTests(){}
  
      static final double NaNd = Double.NaN;
*** 262,272 ****
          // For powers of 2 less than 2^(-27), the second and
          // subsequent terms of the Taylor series expansion will get
          // rounded away since |n-n^3| > 53, the binary precision of a
          // double significand.
  
!         for(int i = DoubleConsts.MIN_SUB_EXPONENT; i < -27; i++) {
              double d = Math.scalb(2.0, i);
  
              // Result and expected are the same.
              failures += testSinhCaseWithUlpDiff(d, d, 2.5);
          }
--- 265,275 ----
          // For powers of 2 less than 2^(-27), the second and
          // subsequent terms of the Taylor series expansion will get
          // rounded away since |n-n^3| > 53, the binary precision of a
          // double significand.
  
!         for(int i = MIN_SUB_EXPONENT; i < -27; i++) {
              double d = Math.scalb(2.0, i);
  
              // Result and expected are the same.
              failures += testSinhCaseWithUlpDiff(d, d, 2.5);
          }
*** 340,350 ****
              failures += testSinhCaseWithUlpDiff(input, expected, 4.0);
          }
  
          // sinh(x) overflows for values greater than 710; in
          // particular, it overflows for all 2^i, i > 10.
!         for(int i = 10; i <= DoubleConsts.MAX_EXPONENT; i++) {
              double d = Math.scalb(2.0, i);
  
              // Result and expected are the same.
              failures += testSinhCaseWithUlpDiff(d,
                                                  Double.POSITIVE_INFINITY, 0.0);
--- 343,353 ----
              failures += testSinhCaseWithUlpDiff(input, expected, 4.0);
          }
  
          // sinh(x) overflows for values greater than 710; in
          // particular, it overflows for all 2^i, i > 10.
!         for(int i = 10; i <= Double.MAX_EXPONENT; i++) {
              double d = Math.scalb(2.0, i);
  
              // Result and expected are the same.
              failures += testSinhCaseWithUlpDiff(d,
                                                  Double.POSITIVE_INFINITY, 0.0);
*** 621,631 ****
  
          // For powers of 2 less than 2^(-27), the second and
          // subsequent terms of the Taylor series expansion will get
          // rounded.
  
!         for(int i = DoubleConsts.MIN_SUB_EXPONENT; i < -27; i++) {
              double d = Math.scalb(2.0, i);
  
              // Result and expected are the same.
              failures += testCoshCaseWithUlpDiff(d, 1.0, 2.5);
          }
--- 624,634 ----
  
          // For powers of 2 less than 2^(-27), the second and
          // subsequent terms of the Taylor series expansion will get
          // rounded.
  
!         for(int i = MIN_SUB_EXPONENT; i < -27; i++) {
              double d = Math.scalb(2.0, i);
  
              // Result and expected are the same.
              failures += testCoshCaseWithUlpDiff(d, 1.0, 2.5);
          }
*** 699,709 ****
              failures += testCoshCaseWithUlpDiff(input, expected, 4.0);
          }
  
          // cosh(x) overflows for values greater than 710; in
          // particular, it overflows for all 2^i, i > 10.
!         for(int i = 10; i <= DoubleConsts.MAX_EXPONENT; i++) {
              double d = Math.scalb(2.0, i);
  
              // Result and expected are the same.
              failures += testCoshCaseWithUlpDiff(d,
                                                  Double.POSITIVE_INFINITY, 0.0);
--- 702,712 ----
              failures += testCoshCaseWithUlpDiff(input, expected, 4.0);
          }
  
          // cosh(x) overflows for values greater than 710; in
          // particular, it overflows for all 2^i, i > 10.
!         for(int i = 10; i <= Double.MAX_EXPONENT; i++) {
              double d = Math.scalb(2.0, i);
  
              // Result and expected are the same.
              failures += testCoshCaseWithUlpDiff(d,
                                                  Double.POSITIVE_INFINITY, 0.0);
*** 980,990 ****
          // For powers of 2 less than 2^(-27), the second and
          // subsequent terms of the Taylor series expansion will get
          // rounded away since |n-n^3| > 53, the binary precision of a
          // double significand.
  
!         for(int i = DoubleConsts.MIN_SUB_EXPONENT; i < -27; i++) {
              double d = Math.scalb(2.0, i);
  
              // Result and expected are the same.
              failures += testTanhCaseWithUlpDiff(d, d, 2.5);
          }
--- 983,993 ----
          // For powers of 2 less than 2^(-27), the second and
          // subsequent terms of the Taylor series expansion will get
          // rounded away since |n-n^3| > 53, the binary precision of a
          // double significand.
  
!         for(int i = MIN_SUB_EXPONENT; i < -27; i++) {
              double d = Math.scalb(2.0, i);
  
              // Result and expected are the same.
              failures += testTanhCaseWithUlpDiff(d, d, 2.5);
          }
*** 994,1004 ****
  
          for(int i = 22; i < 32; i++) {
              failures += testTanhCaseWithUlpDiff(i, 1.0, 2.5);
          }
  
!         for(int i = 5; i <= DoubleConsts.MAX_EXPONENT; i++) {
              double d = Math.scalb(2.0, i);
  
              failures += testTanhCaseWithUlpDiff(d, 1.0, 2.5);
          }
  
--- 997,1007 ----
  
          for(int i = 22; i < 32; i++) {
              failures += testTanhCaseWithUlpDiff(i, 1.0, 2.5);
          }
  
!         for(int i = 5; i <= Double.MAX_EXPONENT; i++) {
              double d = Math.scalb(2.0, i);
  
              failures += testTanhCaseWithUlpDiff(d, 1.0, 2.5);
          }