Uploaded image for project: 'JDK'
  1. JDK
  2. JDK-4462897

JDI spec: ClassType.newInstance() throws IllegalArgumentException

    Details

    • Subcomponent:
    • Resolved In Build:
      b10
    • CPU:
      generic
    • OS:
      generic

      Description



      Name: elR10090 Date: 05/24/2001




      The method
                 ClassType.newInstance(ThreadReference thread,
                                       Method method,
                                       java.util.List arguments,
                                       int options)
      throws IllegalArgumentException
      when it is invoked to create new instance of a ClassType object
      which mirrors an inner class and an outer class extends the class Thread.

      This is from comments in debugger's source code file:

       * The test works as follows.
       * A debugger launchs a debuggee which creates new thread, thread2
       * a tested class TestClass1 is specified within a class
       * Threadnewinstance002a extends Thread
       * After getting thread2 running but locked at a monitor
       * the debugger informs the debugger of the thread2 creation
       * and waits for an instruction from it.
       * Upon receiving the message from the debuggee, the debugger
       * sets up a breakpoint for the thread2 and instructs the
       * debuggee to unlock the thread2 and after getting it suspended
       * at the breakpoint, prepares arguments and invokes the method.
       * After the method completes, the debugger checks up on
       * a returned ObjectReference value;
       * the following is expected to be true:
       * objRef.referenceType().equals(classType)
       * where
       * ObjectReference objRef - is returned value
       * ClassType classType - is a mirror of the tested class.



      This result is observed
      when HS 1.3.1-rc2-b23 or 1.4.0-beta-b65 is runnning a test program
      on the following H/S configurations:

       - SUNW Ultra1: sparc 200MHz, RAM 128Mb;
         OS: Solaris-8;
         JVM: Client & Server
       - Intel: dual Pentium-III 600MHz processor, RAM 512Mb;
         OS: Solaris-8;
         JVM: Client & Server
       - Intel: dual Pentium-III 600MHz processor, RAM 512Mb;
         OS: Linux/RedHat6.2;
         JVM: Client & Server
       - Intel: Pentium-II 350MHz, RAM 128Mb;
         OS: WinNT/4-Workstation;
         JVM: Client & Server


      Corresponding code fragments in a debugger and a debuggee
      and corresponding log for the tested case is below.



      Steps to reproduce the bug:
      1. cd /net/sqesvr.eng/export/vsn/GammaBase/Bugs/{this bug ID}
      2. sh doit.sh {JAVA_HOME}


          This bug affects the following testbase_nsk tests:
          
          nsk/jdi/ClassType/newInstance/newinstance002


      The tests will be in the next release of testbase_nsk;
      the current release of testbase_nsk (1.4) is accessable through:

          /net/sqesvr.eng/export/vsn/VM/testbase/testbase_nsk.v14



      ///////////////////////////////////////////////////////////////////////

      // code fragments in the debugger

                  int expresult = returnCode0;


                  eventRManager = vm.eventRequestManager();
                  eventQueue = vm.eventQueue();

                  String breakpointMethod1 = "runt1";

                  String bpLine1 = "breakpointLineNumber1";

                  List allThreads = null;
                  ListIterator listIterator = null;
                  List classes = null;

                  BreakpointRequest breakpRequest1 = null;
                  
                  ClassType classType = null;

                  label0: {

                      log2("getting ThreadReference object");
                      try {
                          allThreads = vm.allThreads();
                          classes = vm.classesByName(threadClassName);
                          threadClass = (ReferenceType) classes.get(0);
                      } catch ( Exception e) {
                          log3("ERROR: Exception at very beginning !? : " + e);
                          expresult = returnCode1;
                          break label0;
                      }


                      listIterator = allThreads.listIterator();
                      for (;;) {
                          try {
                              thread2 = (ThreadReference) listIterator.next();
                              if (thread2.name().equals(threadName))
                                  break ;
                          } catch ( NoSuchElementException e ) {
                              log3("ERROR: NoSuchElementException for listIterator.next()");
                              log3("ERROR: NO THREAD2 ?????????!!!!!!!");
                              expresult = returnCode1;
                              break label0;
                          }
                      }

                      log2("setting up a breakpoint");

                      breakpRequest1 = settingBreakpoint(breakpointMethod1, bpLine1, "one");
                      if (breakpRequest1 == null) {
                          expresult = returnCode1;
                          break label0;
                      }
                  }

                  label1: {

                      if (expresult != returnCode0)
                             break label1;

                      log2(" enabling breakpRequest1");
                      breakpRequest1.enable();

                      log2(" forcing the main thread to leave synchronized block");
                      pipe.println("continue");
                      line = pipe.readln();
                      if (!line.equals("docontinue")) {
                          log3("ERROR: returned string is not 'docontinue'");
                          expresult = returnCode4;
                          break label1;
                      }

                      log2(" getting BreakpointEvent");
                      expresult = breakpoint();
                      if (expresult != returnCode0)
                          break label1;
                      log2(" thread2 is at breakpoint");


                      log2("......getting ClassType classType - an object to apply newInstance()");
                      classes = vm.classesByName(testedClassName);
                      testedClass = (ReferenceType) classes.get(0);
                      classType = (ClassType) testedClass;

                      List invokeMethods = testedClass.methods();
                      ListIterator li = invokeMethods.listIterator();

                      Method invokeMethod = null;

                      log2("......getting Method invokeMethod - a constructor to invoke; 2-nd
      argument");
                      try {
                          for (;;) {
                              invokeMethod = (Method) li.next();
                              if (!invokeMethod.isConstructor())
                                  continue;
                              if (invokeMethod.arguments().size() == 0)
                                  break;
                          }
                      } catch ( AbsentInformationException e1 ) {
                          log2(" AbsentInformationException ");
                          break label1;
                      } catch ( NoSuchElementException e2 ) {
                          log3("ERROR: NoSuchElementException ");
                          expresult = returnCode2;
                          break label1;
                      }


                      // this is only to get an empty List with JDI methods but not with API List
      methods
                      log2("......forming an empty List argumentList for 3-d argument");
                      log2(" List argumentList = testedClass.methodsByName('m');");
                      List argumentList = testedClass.methodsByName("m");
                      log2(" argumentList.clear();");
                      argumentList.clear();


                      ObjectReference objRef = null;
                     
                      log2("......ObjectReference objRef = classType.newInstance(thread2, invokeMethod,
      argumentList, 0);");
                      log2(" No Exception is expected");
                      try {
                          objRef = classType.newInstance(thread2,
                                           invokeMethod, argumentList, 0);
                          if (objRef == null)
                              log2(" objRe == null");
                          

                          log2(" ReferenceType refType = objRef.referenceType();");
                          ReferenceType refType = objRef.referenceType();
                          
                          log2(" ClassType cType = (ClassType) refType;");
                          ClassType cType = (ClassType) refType;

                          log2("......checking up on: cType.equals(classType); ");
                          if (!cType.equals(classType)) {
                              log3("ERROR: !cType.equals(classType)");
                              expresult = returnCode1;
                          }
                          
                      } catch ( Exception e ) {
                                   log3("ERROR: Exception for classType.newInstance() :" + e);
                                   expresult = returnCode1;
                      }
      ===============================================================
      // code fragments in the debuggee

      class Threadnewinstance002a extends Thread {

          public Threadnewinstance002a(String threadName) {
              super(threadName);
          }
          
          public static Object waitnotifyObj = new Object();
          public static Object lockingObject = new Object();
                      
          public void run() {
              log("method 'run' enter");
              synchronized (waitnotifyObj) {
                  log("entered into block: synchronized (waitnotifyObj)");
                  waitnotifyObj.notify(); }
              log("exited from block: synchronized (waitnotifyObj)");
              synchronized (lockingObject) {
                  log("entered into block: synchronized (lockingObject)"); }
              log("exited from block: synchronized (lockingObject)");
              log("call to the method 'runt1'");
              runt1();
              log("returned from the method 'runt1'");
              log("method 'run' exit");
              return;
          }
          
          public void runt1() {

              int i0 = 0;
              log("method 'runt1': enter");
              i0 = 1;
              log("method 'runt1': body: i0 == " + i0);
              log("method 'runt1': exit");
              return;
          }

          public static final int breakpointLineNumber1 = 3;


          void log(String str) {
              newinstance002a.log2("thread2: " + str);
          }

          TestClass1 obj1 = new TestClass1();

          public class TestClass1 {

               public TestClass1() {
                   super();
               }

               boolean bl1 = true, bl2 = false;
               byte bt1 = 0, bt2 = 1;
               char ch1 = 0, ch2 = 1;
               double db1 = 0.0d, db2 = 1111111111.0d;
               float fl1 = 0.0f, fl2 = 1111111111.0f;
               int in1 = 0, in2 = 1;
               long ln1 = 0, ln2 = 0x1234567890abcdefL; // ln2 = 1; // ln2 = 2;
               short sh1 = 0, sh2 = 1;

               int m () {
                   return in1;
              }
          }

      }




      ======================================================
      // log with comments


      ==> nsk/jdi/ClassType/newInstance/newinstance002 TESTING BEGINS
      debugee.err> **> debuggee: waiting for an instruction from the debugger ...
      debugee.err> **> debuggee: thread2 is created
      debugee.err> **> debuggee: synchronized (waitnotifyObj) { enter
      debugee.err> **> debuggee: before: test_thread.start()
      debugee.err> **> debuggee: before: waitnotifyObj.wait();
      debugee.err> **> thread2: method 'run' enter
      debugee.err> **> thread2: entered into block: synchronized (waitnotifyObj)
      debugee.err> **> thread2: exited from block: synchronized (waitnotifyObj)
      debugee.err> **> debuggee: after: waitnotifyObj.wait();

      ==> nsk/jdi/ClassType/newInstance/newinstance002 new checkready: #0
      --> debugger: getting ThreadReference object
      --> debugger: setting up a breakpoint
      --> debugger: setting up a breakpoint: method: 'runt1' line: breakpointLineNumber1
      --> debugger: a breakpoint has been set up
      --> debugger: enabling breakpRequest1
      --> debugger: forcing the main thread to leave synchronized block
      debugee.err> **> debuggee: mainThread is out of: synchronized (lockingObject) {
      debugee.err> **> debuggee: waiting for an instruction from the debugger ...
      debugee.err> **> thread2: entered into block: synchronized (lockingObject)
      debugee.err> **> thread2: exited from block: synchronized (lockingObject)
      debugee.err> **> thread2: call to the method 'runt1'
      debugee.err> **> thread2: method 'runt1': enter
      --> debugger: getting BreakpointEvent
      --> debugger: waiting for BreakpointEvent
      --> debugger: new: eventSet = eventQueue.remove();
      --> debugger: : eventSet != null; size == 1
      --> debugger: VMStartEvent removed
      --> debugger: new: eventSet = eventQueue.remove();
      --> debugger: : eventSet != null; size == 1
      --> debugger: BreakpointEvent removed
      --> debugger: : eventSet == null: EventQueue is empty
      --> debugger: thread2 is at breakpoint
      --> debugger: ......getting ClassType classType - an object to apply newInstance()
      --> debugger: ......getting Method invokeMethod - a constructor to invoke; 2-nd argument
      --> debugger: ......forming an empty List argumentList for 3-d argument
      --> debugger: List argumentList = testedClass.methodsByName('m');
      --> debugger: argumentList.clear();
      --> debugger: ......ObjectReference objRef = classType.newInstance(thread2, invokeMethod,
      argumentList, 0);
      --> debugger: No Exception is expected
      # ERROR: ##> debugger: ERROR: Exception for classType.newInstance()
      :java.lang.IllegalArgumentException: Invalid argument count
                                                                           
      ^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^


      debugee.err> **> thread2: method 'runt1': body: i0 == 1
      debugee.err> **> thread2: method 'runt1': exit
      debugee.err> **> thread2: returned from the method 'runt1'
      debugee.err> **> thread2: method 'run' exit
      --> debugger: the end of testing
      debugee.err> **> debuggee: waiting for an instruction from the debugger ...
      --> debugger: : returned string is 'checkend'

      ==> nsk/jdi/ClassType/newInstance/newinstance002 TESTING ENDS

      ----------------------------------------------------------------------



      ======================================================================

        Attachments

          Issue Links

            Activity

              People

              • Assignee:
                dtitov Daniil Titov
                Reporter:
                latkinsunw Latkin Latkin (Inactive)
              • Votes:
                0 Vote for this issue
                Watchers:
                6 Start watching this issue

                Dates

                • Created:
                  Updated:
                  Resolved:
                  Imported:
                  Indexed: