gt:             int instruction = ((IntegerValue)
context: /*
   * Copyright (c) 2001, 2018, 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.
   */
  
  package nsk.jdi.VMDeathEvent._itself_;
  
  import nsk.share.*;
  import nsk.share.jpda.*;
  import nsk.share.jdi.*;
  
  import com.sun.jdi.*;
  import com.sun.jdi.event.*;
  import com.sun.jdi.request.*;
  
  import java.util.*;
  import java.io.*;
  
  /**
   * The test for the implementation of an object of the type     <BR>
   * VMDeathEvent.                                                <BR>
   *                                                              <BR>
   * The test checks that the interface                           <BR>
   * <code>com.sun.jdi.VMDeathEvent</code>                        <BR>
   * complies with its spec.                                      <BR>
   * <BR>
   * The case to test includes receiving the VMDeathEvent         <BR>
   * as a response to VirtualMachine.exit(int);                   <BR>
   * <BR>
   * The test works as follows.                                   <BR>
   * <BR>
   * Upon launching debuggee's VM which will be suspended,                <BR>
   * a debugger waits for the VMStartEvent within a predefined            <BR>
   * time interval. If no the VMStartEvent received, the test is FAILED.  <BR>
   * Upon getting the VMStartEvent, it makes the request for debuggee's   <BR>
   * ClassPrepareEvent with SUSPEND_EVENT_THREAD, resumes the VM,         <BR>
   * and waits for the event within the predefined time interval.         <BR>
   * If no the ClassPrepareEvent received, the test is FAILED.            <BR>
   * Upon getting the ClassPrepareEvent,                                  <BR>
   * the debugger sets up the breakpoint with SUSPEND_EVENT_THREAD        <BR>
   * within debuggee's special methodForCommunication().                  <BR>
   * <BR>
   * Then to test the interface,                                          <BR>
   * the debugger invokes the method VirtualMachine.exit() and checks up  <BR>
   * on the event received in the response to.                            <BR>
   * <BR>
   */
  
  public class vmdeath002 {
  
      //----------------------------------------------------- templete section
      static final int PASSED = 0;
      static final int FAILED = 2;
      static final int PASS_BASE = 95;
  
      //----------------------------------------------------- templete parameters
      static final String
      sHeader1 = "\n==> nsk/jdi/VMDeathEvent/_itself_/vmdeath002 ",
      sHeader2 = "--> debugger: ",
      sHeader3 = "##> debugger: ";
  
      //----------------------------------------------------- main method
  
      public static void main (String argv[]) {
  
          int result = run(argv, System.out);
  
          System.exit(result + PASS_BASE);
      }
  
      public static int run (String argv[], PrintStream out) {
  
          int exitCode = new vmdeath002().runThis(argv, out);
  
          if (exitCode != PASSED) {
              System.out.println("TEST FAILED");
          }
          return testExitCode;
      }
  
      //--------------------------------------------------   log procedures
  
      private static Log  logHandler;
  
      private static void log1(String message) {
          logHandler.display(sHeader1 + message);
      }
      private static void log2(String message) {
          logHandler.display(sHeader2 + message);
      }
      private static void log3(String message) {
          logHandler.complain(sHeader3 + message);
      }
  
      //  ************************************************    test parameters
  
      private String debuggeeName =
          "nsk.jdi.VMDeathEvent._itself_.vmdeath002a";
  
      //====================================================== test program
      //------------------------------------------------------ common section
  
      static Debugee          debuggee;
      static ArgumentHandler  argsHandler;
  
      static int waitTime;
  
      static VirtualMachine      vm            = null;
      static EventRequestManager eventRManager = null;
      static EventQueue          eventQueue    = null;
      static EventSet            eventSet      = null;
      static EventIterator       eventIterator = null;
  
      static ReferenceType       debuggeeClass = null;
  
      static int  testExitCode = PASSED;
  
  
      //------------------------------------------------------ methods
  
      private int runThis (String argv[], PrintStream out) {
  
          argsHandler     = new ArgumentHandler(argv);
          logHandler      = new Log(out, argsHandler);
          Binder binder   = new Binder(argsHandler, logHandler);
  
          waitTime        = argsHandler.getWaitTime() * 60000;
  
          try {
              log2("launching a debuggee :");
              log2("       " + debuggeeName);
              if (argsHandler.verbose()) {
                  debuggee = binder.bindToDebugee(debuggeeName + " -vbs");
              } else {
                  debuggee = binder.bindToDebugee(debuggeeName);
              }
              if (debuggee == null) {
                  log3("ERROR: no debuggee launched");
                  return FAILED;
              }
              log2("debuggee launched");
          } catch ( Exception e ) {
              log3("ERROR: Exception : " + e);
              log2("       test cancelled");
              return FAILED;
          }
  
          debuggee.redirectOutput(logHandler);
  
          vm = debuggee.VM();
  
          eventQueue = vm.eventQueue();
          if (eventQueue == null) {
              log3("ERROR: eventQueue == null : TEST ABORTED");
              vm.exit(PASS_BASE);
              return FAILED;
          }
  
          log2("invocation of the method runTest()");
          switch (runTest()) {
  
              case 0 :  log2("test phase has finished normally");
                        log2("   waiting for the debuggee to finish ...");
                        debuggee.waitFor();
  
                        log2("......getting the debuggee's exit status");
                        int status = debuggee.getStatus();
                        if (status != PASS_BASE) {
                            log3("ERROR: debuggee returned UNEXPECTED exit status: " +
                                status + " != PASS_BASE");
                            testExitCode = FAILED;
                        } else {
                            log2("......debuggee returned expected exit status: " +
                                status + " == PASS_BASE");
                        }
                        break;
  
              default : log3("ERROR: runTest() returned unexpected value");
  
              case 1 :  log3("test phase has not finished normally: debuggee is still alive");
                        log2("......forcing: vm.exit();");
                        testExitCode = FAILED;
                        try {
                            vm.exit(PASS_BASE);
                        } catch ( Exception e ) {
                            log3("ERROR: Exception : " + e);
                        }
                        break;
  
              case 2 :  log3("test cancelled due to VMDisconnectedException");
                        log2("......trying: vm.process().destroy();");
                        testExitCode = FAILED;
                        try {
                            Process vmProcess = vm.process();
                            if (vmProcess != null) {
                                vmProcess.destroy();
                            }
                        } catch ( Exception e ) {
                            log3("ERROR: Exception : " + e);
                        }
                        break;
              }
  
          return testExitCode;
      }
  
  
     /*
      * Return value: 0 - normal end of the test
      *               1 - ubnormal end of the test
      *               2 - VMDisconnectedException while test phase
      */
  
      private int runTest() {
  
          try {
              testRun();
  
              log2("waiting for VMDeathEvent");
              getEventSet();
              Event event = eventIterator.nextEvent();
              if ( !(event instanceof VMDeathEvent) ) {
                  testExitCode = FAILED;
                  log3("ERROR: last event is not the VMDeathEvent");
  
                  if (event instanceof VMDisconnectEvent)
                     log3("      event is the VMDisconnectEvent     ????");
                  else
                     log3("      event is NOT the VMDisconnectEvent ????!!!!!!!");
                  return 2;
  
              }
              return 0;
          } catch ( VMDisconnectedException e ) {
              log3("ERROR: VMDisconnectedException : " + e);
              return 2;
          } catch ( Exception e ) {
              log3("ERROR: Exception : " + e);
              return 1;
          }
  
      }
  
      private void testRun()
                   throws JDITestRuntimeException, Exception {
  
          eventRManager = vm.eventRequestManager();
  
          ClassPrepareRequest cpRequest = eventRManager.createClassPrepareRequest();
          cpRequest.setSuspendPolicy( EventRequest.SUSPEND_EVENT_THREAD);
          cpRequest.addClassFilter(debuggeeName);
  
          cpRequest.enable();
          vm.resume();
          getEventSet();
          cpRequest.disable();
  
          ClassPrepareEvent event = (ClassPrepareEvent) eventIterator.next();
          debuggeeClass = event.referenceType();
  
          if (!debuggeeClass.name().equals(debuggeeName))
             throw new JDITestRuntimeException("** Unexpected ClassName for ClassPrepareEvent **");
  
          log2("      received: ClassPrepareEvent for debuggeeClass");
  
          String bPointMethod = "methodForCommunication";
          String lineForComm  = "lineForComm";
          BreakpointRequest bpRequest;
  
          bpRequest = settingBreakpoint(debuggee.threadByNameOrThrow("main"),
                                        debuggeeClass,
                                        bPointMethod, lineForComm, "zero");
          bpRequest.enable();
  
      //------------------------------------------------------  testing section
  
          log1("     TESTING BEGINS");
  
          for (int i = 0; ; i++) {
  
              vm.resume();
              breakpointForCommunication();
  
  