gt:             Field fsbl1 = execClass.fieldByName("bl1");
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.PrimitiveValue.charValue;
  
  import nsk.share.*;
  import nsk.share.jpda.*;
  import nsk.share.jdi.*;
  
  import com.sun.jdi.*;
  import java.util.*;
  import java.io.*;
  
  /**
   * The test for the implementation of an object of the type     <BR>
   * PrimitiveValue.                                              <BR>
   *                                                              <BR>
   * The test checks up that results of the method                <BR>
   * <code>com.sun.jdi.PrimitiveValue.charValue()</code>          <BR>
   * complies with its spec.                                      <BR>
   * <BR>
   * The cases for testing are as follows :               <BR>
   *                                                      <BR>
   * when a gebuggee executes the following :             <BR>
   *   static boolean bl1 = true;                         <BR>
   *   static boolean bl0 = false;                        <BR>
   *   static byte    bt1 = Byte.MAX_VALUE;               <BR>
   *   static byte    bt0 = 0;                            <BR>
   *   static char    ch1 = Character.MAX_VALUE;          <BR>
   *   static char    ch0 = 0;                            <BR>
   *   static double  db1 = Double.MAX_VALUE;             <BR>
   *   static double  db0 = 0.0d;                         <BR>
   *   static float   fl1 = Float.MAX_VALUE;              <BR>
   *   static float   fl0 = 0.0f;                         <BR>
   *   static int     in1 = Integer.MAX_VALUE;            <BR>
   *   static int     in0 = 0;                            <BR>
   *   static long    ln1 = Long.MAX_VALUE;               <BR>
   *   static long    ln0 = 0;                            <BR>
   *   static short   sh1 = Short.MAX_VALUE;              <BR>
   *   static short   sh0 = 0;                            <BR>
   *                                                      <BR>
   * which a debugger mirrors as :                        <BR>
   *                                                      <BR>
   *      PrimitiveValue pvbl1, pvbl0, pvbt1, pvbt0,      <BR>
   *                     pvch1, pvch0, pvdb1, pvdb0,      <BR>
   *                     pvfl1, pvfl0, pvin1, pvin0,      <BR>
   *                     pvln1, pvln0, pvsh1, pvsh0;      <BR>
   *                                                      <BR>
   * each of the following is true:                       <BR>
   *                                                      <BR>
   *      pvbl1.charValue() == 1                          <BR>
   *      pvbl0.charValue() == 0                          <BR>
   *      pvbt1.charValue() == (char) Byte.MAX_VALUE      <BR>
   *      pvbt0.charValue() == 0                          <BR>
   *      pvch1.charValue() == Character.MAX_VALUE        <BR>
   *      pvch0.charValue() == 0                          <BR>
   *<BR>
   *<BR>
   *      pvfl1.charValue() == (char) Float.MAX_VALUE     <BR>
   *      pvfl0.charValue() == 0                          <BR>
   *      pvin1.charValue() == (char) Integer.MAX_VALUE   <BR>
   *      pvin0.charValue() == 0                          <BR>
   *      pvln1.charValue() == (char) Long.MAX_VALUE      <BR>
   *      pvln0.charValue() == 0                          <BR>
   *      pvsh1.charValue() == (char) Short.MAX_VALUE     <BR>
   *      pvsh0.charValue() == 0                          <BR>
   * <BR>
   */
  
  public class charvalue001 {
  
      //----------------------------------------------------- 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/PrimitiveValue/charValue/charvalue001",
      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) {
          return new charvalue001().runThis(argv, out);
      }
  
       //--------------------------------------------------   log procedures
  
      //private static boolean verbMode = false;
  
      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.PrimitiveValue.charValue.charvalue001a";
  
      //====================================================== test program
  
      static ArgumentHandler      argsHandler;
      static int                  testExitCode = PASSED;
  
      //------------------------------------------------------ common section
  
      private int runThis (String argv[], PrintStream out) {
  
          Debugee debuggee;
  
          argsHandler     = new ArgumentHandler(argv);
          logHandler      = new Log(out, argsHandler);
          Binder binder   = new Binder(argsHandler, logHandler);
  
          if (argsHandler.verbose()) {
              debuggee = binder.bindToDebugee(debuggeeName + " -vbs");  // *** tp
          } else {
              debuggee = binder.bindToDebugee(debuggeeName);            // *** tp
          }
  
          IOPipe pipe     = new IOPipe(debuggee);
  
          debuggee.redirectStderr(out);
          log2("charvalue001a debuggee launched");
          debuggee.resume();
  
          String line = pipe.readln();
          if ((line == null) || !line.equals("ready")) {
              log3("signal received is not 'ready' but: " + line);
              return FAILED;
          } else {
              log2("'ready' recieved");
          }
  
          VirtualMachine vm = debuggee.VM();
  
      //------------------------------------------------------  testing section
          log1("      TESTING BEGINS");
  
          for (int i = 0; ; i++) {
              pipe.println("newcheck");
              line = pipe.readln();
  
              if (line.equals("checkend")) {
                  log2("     : returned string is 'checkend'");
                  break ;
              } else if (!line.equals("checkready")) {
                  log3("ERROR: returned string is not 'checkready'");
                  testExitCode = FAILED;
                  break ;
              }
  
              log1("new check: #" + i);
  
              //~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~ variable part
  
              List listOfDebuggeeExecClasses = vm.classesByName(debuggeeName);
              if (listOfDebuggeeExecClasses.size() != 1) {
                  testExitCode = FAILED;
                  log3("ERROR: listOfDebuggeeExecClasses.size() != 1");
                  break ;
              }
              ReferenceType execClass =
                          (ReferenceType) listOfDebuggeeExecClasses.get(0);
  
  