/*

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

 * DO NOT ALTER OR REMOVE COPYRIGHT NOTICES OR THIS FILE HEADER.

 *

 * This code is free software; you can redistribute it and/or modify it

 * under the terms of the GNU General Public License version 2 only, as

 * published by the Free Software Foundation.

 *

 * This code is distributed in the hope that it will be useful, but WITHOUT

 * ANY WARRANTY; without even the implied warranty of MERCHANTABILITY or

 * FITNESS FOR A PARTICULAR PURPOSE.  See the GNU General Public License

 * version 2 for more details (a copy is included in the LICENSE file that

 * accompanied this code).

 *

 * You should have received a copy of the GNU General Public License version

 * 2 along with this work; if not, write to the Free Software Foundation,

 * Inc., 51 Franklin St, Fifth Floor, Boston, MA 02110-1301 USA.

 *

 * Please contact Oracle, 500 Oracle Parkway, Redwood Shores, CA 94065 USA

 * or visit www.oracle.com if you need additional information or have any

 * questions.

 */

/*

 * @test Test8004741.java

 * @bug 8004741

 * @summary Missing compiled exception handle table entry for multidimensional array allocation

 *

 * @requires !vm.graal.enabled

 *    -XX:-TieredCompilation -XX:+StressCompiledExceptionHandlers

 *    -XX:+SafepointALot -XX:GuaranteedSafepointInterval=100

 *    compiler.c2.Test8004741

 *    -XX:-TieredCompilation -XX:+StressCompiledExceptionHandlers

 *    compiler.c2.Test8004741

 */

package compiler.c2;

public class Test8004741 extends Thread {

  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.

   */

  static int[][] test(int a, int b) throws Exception {

    int[][] ar;

    try {

      ar = new int[a][b];

    } catch (ThreadDeath e) {

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

      passed++;

      throw(e);

    }

    return ar;

  }

  /* 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();

  }

  public static void main(String[] args) throws Exception {

    // Warm up "test"

    // t will never be started.

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

      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("PASSED");

    } else {

      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);

  }

};