* Copyright (c) 2012, 2013, Oracle and/or its affiliates. All rights reserved.

 * @run main/othervm -Xmx64m -Xbatch -XX:+IgnoreUnrecognizedVMOptions -XX:-TieredCompilation -XX:+StressCompiledExceptionHandlers -XX:+SafepointALot -XX:GuaranteedSafepointInterval=100 Test8004741

  static int passed = 0;

  /**

   * Loop forever allocating 2-d arrays.

   * Catches and rethrows all exceptions; in the case of ThreadDeath, increments passed.

   * Note that passed is incremented here because this is the exception handler with

   * the smallest scope; we only want to declare success in the case where it is highly

   * likely that the test condition

   * (exception in 2-d array alloc interrupted by ThreadDeath)

   * actually occurs.

   */

    int[][] ar;

    } catch (ThreadDeath e) {

      System.out.println("test got ThreadDeath");

      passed++;

  /* Cookbook wait-notify to track progress of test thread. */

  Object progressLock = new Object();

  private static final int NOT_STARTED = 0;

  private static final int RUNNING = 1;

  private static final int STOPPING = 2;

  int progressState = NOT_STARTED;

  void toState(int state) {

    synchronized (progressLock) {

      progressState = state;

      progressLock.notify();

    }

  }

  void waitFor(int state) {

    synchronized (progressLock) {

      while (progressState < state) {

        try {

          progressLock.wait();

        } catch (InterruptedException e) {

          e.printStackTrace();

          System.out.println("unexpected InterruptedException");

          fail();

      }

      if (progressState > state) {

        System.out.println("unexpected test state change, expected " +

                            state + " but saw " + progressState);

        fail();

      }

    }

  }

  /**

   * Loops running test until some sort of an exception or error,

   * expects to see ThreadDeath.

   */

  public void run() {

    try {

      // Print before state change, so that other thread is most likely

      // to see this thread executing calls to test() in a loop.

      System.out.println("thread running");

      toState(RUNNING);

      while (true) {

        // (2,2) (2,10) (2,100) were observed to tickle the bug;

        test(2, 100);

    } catch (ThreadDeath e) {

      // nothing to say, passing was incremented by the test.

    } catch (Throwable e) {

      e.printStackTrace();

      System.out.println("unexpected Throwable " + e);

      fail();

    }

    toState(STOPPING);

  }

  /**

   * Runs a single trial of the test in a thread.

   * No single trial is definitive, since the ThreadDeath

   * exception might not land in the tested region of code.

   */

  public static void threadTest() throws InterruptedException {

    Test8004741 t = new Test8004741();

    t.start();

    t.waitFor(RUNNING);

    Thread.sleep(100);

    System.out.println("stopping thread");

    t.stop();

    t.waitFor(STOPPING);

    t.join();

    // Warm up "test"

    // t will never be started.

      test(2, 100);

    }

    // Will this sleep help ensure that the compiler is run?

    Thread.sleep(500);

    passed = 0;

    try {

      test(-1, 100);

      System.out.println("Missing NegativeArraySizeException #1");

      fail();

    } catch ( java.lang.NegativeArraySizeException e ) {

      System.out.println("Saw expected NegativeArraySizeException #1");

    try {

      test(100, -1);

      fail();

      System.out.println("Missing NegativeArraySizeException #2");

      fail();

    } catch ( java.lang.NegativeArraySizeException e ) {

      System.out.println("Saw expected NegativeArraySizeException #2");

    }

    /* Test repetitions.  If the test succeeds-mostly, it succeeds,

     * as long as it does not crash (the outcome if the exception range

     * table entry for the array allocation is missing).

     */

    int N = 12;

    for (int n = 0; n < N; n++) {

      threadTest();

    }

    if (passed > N/2) {

      System.out.println("Saw " + passed + " out of " + N + " possible ThreadDeath hits");

      System.out.println("Too few ThreadDeath hits; expected at least " + N/2 +

                         " but saw only " + passed);

      fail();

  static void fail() {

    System.out.println("FAILED");

    System.exit(97);

  }