*** old/test/compiler/intrinsics/mathexact/RepeatTest.java	Wed Oct 23 08:41:26 2013
--- new/test/compiler/intrinsics/mathexact/AddExactIRepeatTest.java	Wed Oct 23 08:41:26 2013

*** 23,107 ****
--- 23,109 ----
  
  /*
   * @test
   * @bug 8025657
   * @summary Test repeating addExact
!  * @compile AddExactIRepeatTest.java Verify.java
!  * @run main AddExactIRepeatTest
   *
   */
  
  import java.lang.ArithmeticException;
  
  public class RepeatTest {
+ public class AddExactIRepeatTest {
      public static void main(String[] args) {
+         runTest(new Verify.AddExactI());
+     }
+ 
+     public static int nonExact(int x, int y, Verify.BinaryMethod method) {
+         int result = method.unchecked(x, y);
+         result += method.unchecked(x, y);
+         result += method.unchecked(x, y);
+         result += method.unchecked(x, y);
+         return result;
+     }
+ 
+     public static void runTest(Verify.BinaryMethod method) {
          java.util.Random rnd = new java.util.Random();
          for (int i = 0; i < 50000; ++i) {
              int x = Integer.MAX_VALUE - 10;
!       int y = Integer.MAX_VALUE - 10 + rnd.nextInt(5); //rnd.nextInt() / 2;
!             int y = Integer.MAX_VALUE - 10 + rnd.nextInt(5);
  
              int c = rnd.nextInt() / 2;
              int d = rnd.nextInt() / 2;
  
!       int a = addExact(x, y);
!             int a = catchingExact(x, y, method);
  
              if (a != 36) {
!           throw new RuntimeException("a != 0 : " + a);
!                 throw new RuntimeException("a != 36 : " + a);
              }
  
!             int b = nonExact(c, d, method);
!       int n = addExact2(c, d);
!             int n = exact(c, d, method);
  
  
              if (n != b) {
                  throw new RuntimeException("n != b : " + n + " != " + b);
              }
          }
      }
  
!   public static int addExact2(int x, int y) {
!     public static int exact(int x, int y, Verify.BinaryMethod method) {
          int result = 0;
!       result += java.lang.Math.addExact(x, y);
!       result += java.lang.Math.addExact(x, y);
!       result += java.lang.Math.addExact(x, y);
!       result += java.lang.Math.addExact(x, y);
!         result += method.checkMethod(x, y);
!         result += method.checkMethod(x, y);
!         result += method.checkMethod(x, y);
!         result += method.checkMethod(x, y);
          return result;
      }
  
!   public static int addExact(int x, int y) {
!     public static int catchingExact(int x, int y, Verify.BinaryMethod method) {
          int result = 0;
          try {
              result += 5;
!         result = java.lang.Math.addExact(x, y);
!             result = method.checkMethod(x, y);
          } catch (ArithmeticException e) {
              result += 1;
          }
          try {
              result += 6;
  
!         result += java.lang.Math.addExact(x, y);
!             result += method.checkMethod(x, y);
          } catch (ArithmeticException e) {
              result += 2;
          }
          try {
              result += 7;
!         result += java.lang.Math.addExact(x, y);
!             result += method.checkMethod(x, y);
          } catch (ArithmeticException e) {
              result += 3;
          }
          try {
              result += 8;
!         result += java.lang.Math.addExact(x, y);
!             result += method.checkMethod(x, y);
          } catch (ArithmeticException e) {
              result += 4;
          }
          return result;
      }
  
    public static int nonExact(int x, int y) {
      int result = x + y;
      result += x + y;
      result += x + y;
      result += x + y;
      return result;
    }
  }