Esempio n. 1
0
  void ckThreadGroupValue(Value retValue) {
    Field theValueField = targetClass.fieldByName("ethreadGroupValue");
    ThreadGroupReference vv = (ThreadGroupReference) targetClass.getValue(theValueField);

    ThreadGroupReference rv = (ThreadGroupReference) retValue;
    if (vv != rv) {
      failure("failure: ThreadgGroup: expected " + vv + ", got " + rv);
    } else {
      System.out.println("Passed: ThreadGroup: " + rv);
      earlyReturns++;
    }
  }
Esempio n. 2
0
  void ckClassLoaderValue(Value retValue) {
    Field theValueField = targetClass.fieldByName("eclassLoaderValue");
    ClassLoaderReference vv = (ClassLoaderReference) targetClass.getValue(theValueField);

    ClassLoaderReference rv = (ClassLoaderReference) retValue;
    if (vv != rv) {
      failure("failure: ClassLoader: expected " + vv + ", got " + rv);
    } else {
      System.out.println("Passed: ClassLoader: " + rv);
      earlyReturns++;
    }
  }
Esempio n. 3
0
  void ckObjectValue(Value retValue) {
    ObjectReference theRetValue = (ObjectReference) retValue;

    Field theIVarField = targetClass.fieldByName("eobjectValue");
    ObjectReference theRetValField = (ObjectReference) targetClass.getValue(theIVarField);

    if (!theRetValue.equals(theRetValField)) {
      failure("failure: Object: expected " + theIVarField + ", got " + theRetValField);
    } else {
      System.out.println("Passed: Object: " + theRetValField);
      earlyReturns++;
    }
  }
Esempio n. 4
0
  void ckStringValue(Value retValue) {
    Field theValueField = targetClass.fieldByName("estringValue");
    StringReference theValue = (StringReference) targetClass.getValue(theValueField);

    String vv = theValue.value();
    String rv = ((StringReference) retValue).value();
    if (vv != rv) {
      failure("failure: String: expected " + vv + ", got " + rv);
    } else {
      System.out.println("Passed: String: " + rv);
      earlyReturns++;
    }
  }
Esempio n. 5
0
  void ckShortValue(Value retValue) {
    Field theValueField = targetClass.fieldByName("eshortValue");
    ShortValue theValue = (ShortValue) targetClass.getValue(theValueField);

    short vv = theValue.value();
    short rv = ((ShortValue) retValue).value();
    if (vv != rv) {
      failure("failure: short: expected " + vv + ", got " + rv);
    } else {
      System.out.println("Passed: short " + rv);
      earlyReturns++;
    }
  }
Esempio n. 6
0
  void ckBooleanValue(Value retValue) {
    Field theValueField = targetClass.fieldByName("ebooleanValue");
    BooleanValue theValue = (BooleanValue) targetClass.getValue(theValueField);

    boolean vv = theValue.value();
    boolean rv = ((BooleanValue) retValue).value();
    if (vv != rv) {
      failure("failure: boolean: expected " + vv + ", got " + rv);
    } else {
      System.out.println("Passed: boolean " + rv);
      earlyReturns++;
    }
  }
Esempio n. 7
0
  void ckLongValue(Value retValue) {
    Field theValueField = targetClass.fieldByName("elongValue");
    LongValue theValue = (LongValue) targetClass.getValue(theValueField);

    long vv = theValue.value();
    long rv = ((LongValue) retValue).value();
    if (vv != rv) {
      failure("failure: long: expected " + vv + ", got " + rv);
    } else {
      System.out.println("Passed: long " + rv);
      earlyReturns++;
    }
  }
Esempio n. 8
0
  void ckIntValue(Value retValue) {
    Field theValueField = targetClass.fieldByName("eintValue");
    IntegerValue theValue = (IntegerValue) targetClass.getValue(theValueField);

    int vv = theValue.value();
    int rv = ((IntegerValue) retValue).value();
    if (vv != rv) {
      failure("failure: int: expected " + vv + ", got " + rv);
    } else {
      System.out.println("Passed: int " + rv);
      earlyReturns++;
    }
  }
Esempio n. 9
0
  void ckFloatValue(Value retValue) {
    Field theValueField = targetClass.fieldByName("efloatValue");
    FloatValue theValue = (FloatValue) targetClass.getValue(theValueField);

    float vv = theValue.value();
    float rv = ((FloatValue) retValue).value();
    if (vv != rv) {
      failure("failure: float: expected " + vv + ", got " + rv);
    } else {
      System.out.println("Passed: float " + rv);
      earlyReturns++;
    }
  }
Esempio n. 10
0
  void ckDoubleValue(Value retValue) {
    Field theValueField = targetClass.fieldByName("edoubleValue");
    DoubleValue theValue = (DoubleValue) targetClass.getValue(theValueField);

    double vv = theValue.value();
    double rv = ((DoubleValue) retValue).value();
    if (vv != rv) {
      failure("failure: double: expected " + vv + ", got " + rv);
    } else {
      System.out.println("Passed: double " + rv);
      earlyReturns++;
    }
  }
Esempio n. 11
0
  void ckCharValue(Value retValue) {
    Field theValueField = targetClass.fieldByName("echarValue");
    CharValue theValue = (CharValue) targetClass.getValue(theValueField);

    char vv = theValue.value();
    char rv = ((CharValue) retValue).value();
    if (vv != rv) {
      failure("failure: char: expected " + vv + ", got " + rv);
    } else {
      System.out.println("Passed: char " + rv);
      earlyReturns++;
    }
  }
Esempio n. 12
0
  void ckArrayValue(Value retValue) {
    Field theValueField = targetClass.fieldByName("eintArrayValue");
    ArrayReference theValue = (ArrayReference) targetClass.getValue(theValueField);
    IntegerValue theElem2 = (IntegerValue) theValue.getValue(2);

    ArrayReference theRetValue = (ArrayReference) retValue;
    IntegerValue retElem2 = (IntegerValue) theRetValue.getValue(2);
    int vv = theElem2.value();
    int rv = retElem2.value();
    if (vv != rv) {
      failure("failure: in[2]: expected " + vv + ", got " + rv);
    } else {
      System.out.println("Passed: int[2]: " + rv);
      earlyReturns++;
    }
  }
Esempio n. 13
0
  protected void runTests() throws Exception {
    /*
     * Get to the top of main()
     * to determine targetClass and mainThread
     */

    BreakpointEvent bpe = startToMain("EarlyReturnTarg");
    targetClass = (ClassType) bpe.location().declaringType();
    mainThread = bpe.thread();

    /*
     * Ask for method exit events
     */
    MethodExitRequest exitRequest = eventRequestManager().createMethodExitRequest();

    for (int i = 0; i < excludes.length; ++i) {
      exitRequest.addClassExclusionFilter(excludes[i]);
    }
    int sessionSuspendPolicy = EventRequest.SUSPEND_ALL;
    // sessionSuspendPolicy = EventRequest.SUSPEND_EVENT_THREAD;
    // sessionSuspendPolicy = EventRequest.SUSPEND_NONE;
    exitRequest.setSuspendPolicy(sessionSuspendPolicy);
    exitRequest.enable();

    /*
     * Turn on the flag so debugee knows to check for early
     * return values instead of regular return values.
     */
    Field flagField = targetClass.fieldByName("debuggerWatching");
    targetClass.setValue(flagField, vm().mirrorOf(true));

    /*
     * We set and enable breakpoints on all of the interesting
     * methods called by doit().  In the breakpointReached()
     * handler we force an early return with a different return
     * value.
     *
     * The MethodExitEvent handler will keep score.
     */

    setBreakpoint("EarlyReturnTarg", "s_bytef", "(I)B");
    setBreakpoint("EarlyReturnTarg", "s_charf", "()C");
    setBreakpoint("EarlyReturnTarg", "s_doublef", "()D");
    setBreakpoint("EarlyReturnTarg", "s_floatf", "()F");
    setBreakpoint("EarlyReturnTarg", "s_intf", "()I");
    setBreakpoint("EarlyReturnTarg", "s_longf", "()J");
    setBreakpoint("EarlyReturnTarg", "s_shortf", "()S");
    setBreakpoint("EarlyReturnTarg", "s_booleanf", "()Z");

    setBreakpoint("EarlyReturnTarg", "s_stringf", "()Ljava/lang/String;");
    setBreakpoint("EarlyReturnTarg", "s_classf", "()Ljava/lang/Class;");
    setBreakpoint("EarlyReturnTarg", "s_classLoaderf", "()Ljava/lang/ClassLoader;");
    setBreakpoint("EarlyReturnTarg", "s_threadf", "()Ljava/lang/Thread;");
    setBreakpoint("EarlyReturnTarg", "s_threadGroupf", "()Ljava/lang/ThreadGroup;");
    setBreakpoint("EarlyReturnTarg", "s_intArrayf", "()[I");
    setBreakpoint("EarlyReturnTarg", "s_nullObjectf", "()Ljava/lang/Object;");
    setBreakpoint("EarlyReturnTarg", "s_objectf", "()Ljava/lang/Object;");
    setBreakpoint("EarlyReturnTarg", "s_voidf", "()V");

    setBreakpoint("EarlyReturnTarg", "i_bytef", "(I)B");
    setBreakpoint("EarlyReturnTarg", "i_charf", "()C");
    setBreakpoint("EarlyReturnTarg", "i_doublef", "()D");
    setBreakpoint("EarlyReturnTarg", "i_floatf", "()F");
    setBreakpoint("EarlyReturnTarg", "i_intf", "()I");
    setBreakpoint("EarlyReturnTarg", "i_longf", "()J");
    setBreakpoint("EarlyReturnTarg", "i_shortf", "()S");
    setBreakpoint("EarlyReturnTarg", "i_booleanf", "()Z");
    setBreakpoint("EarlyReturnTarg", "i_stringf", "()Ljava/lang/String;");
    setBreakpoint("EarlyReturnTarg", "i_intArrayf", "()[I");
    setBreakpoint("EarlyReturnTarg", "i_classf", "()Ljava/lang/Class;");
    setBreakpoint("EarlyReturnTarg", "i_classLoaderf", "()Ljava/lang/ClassLoader;");
    setBreakpoint("EarlyReturnTarg", "i_threadf", "()Ljava/lang/Thread;");
    setBreakpoint("EarlyReturnTarg", "i_threadGroupf", "()Ljava/lang/ThreadGroup;");
    setBreakpoint("EarlyReturnTarg", "i_nullObjectf", "()Ljava/lang/Object;");
    setBreakpoint("EarlyReturnTarg", "i_objectf", "()Ljava/lang/Object;");
    setBreakpoint("EarlyReturnTarg", "i_voidf", "()V");

    /* Here we go.  This adds 'this' as a listener so
     * that our handlers above will be called.
     */
    listenUntilVMDisconnect();

    if (earlyReturns != expectedEarlyReturns) {
      failure("failure: Expected " + expectedEarlyReturns + ", but got " + earlyReturns);
    }
    System.out.println("All done, " + earlyReturns + " passed");

    if (!testFailed) {
      System.out.println();
      System.out.println("EarlyReturnTest: passed");
    } else {
      System.out.println();
      System.out.println("EarlyReturnTest: failed");
      throw new Exception("EarlyReturnTest: failed");
    }
  }
Esempio n. 14
0
  public void breakpointReached(BreakpointEvent event) {
    String origMethodName = event.location().method().name();
    String methodName = origMethodName.substring(2);
    ThreadReference tr = event.thread();

    if (vm().canForceEarlyReturn()) {

      try {

        if ("bytef".equals(methodName)) {
          Field theValueField = targetClass.fieldByName("ebyteValue");
          ByteValue theValue = (ByteValue) targetClass.getValue(theValueField);
          tr.forceEarlyReturn(theValue);
          /*
           * See what happens if we access the stack after the force
           * and before the resume.  Disabling this since spec says
           * the stack is undefined.  This type of code can be used to
           * pursue just what that means.
           *
           * StackFrame sf = tr.frame(0);
           * List<Value> ll = sf.getArgumentValues();
           * for (Value vv: ll) {
           *     System.out.println("vv = " + vv);
           * }
           */
        } else if ("charf".equals(methodName)) {
          Field theValueField = targetClass.fieldByName("echarValue");
          CharValue theValue = (CharValue) targetClass.getValue(theValueField);
          tr.forceEarlyReturn(theValue);
        } else if ("doublef".equals(methodName)) {
          Field theValueField = targetClass.fieldByName("edoubleValue");
          DoubleValue theValue = (DoubleValue) targetClass.getValue(theValueField);
          tr.forceEarlyReturn(theValue);
        } else if ("floatf".equals(methodName)) {
          Field theValueField = targetClass.fieldByName("efloatValue");
          FloatValue theValue = (FloatValue) targetClass.getValue(theValueField);
          tr.forceEarlyReturn(theValue);
        } else if ("intf".equals(methodName)) {
          Field theValueField = targetClass.fieldByName("eintValue");
          IntegerValue theValue = (IntegerValue) targetClass.getValue(theValueField);
          tr.forceEarlyReturn(theValue);
        } else if ("longf".equals(methodName)) {
          Field theValueField = targetClass.fieldByName("elongValue");
          LongValue theValue = (LongValue) targetClass.getValue(theValueField);
          tr.forceEarlyReturn(theValue);
        } else if ("shortf".equals(methodName)) {
          Field theValueField = targetClass.fieldByName("eshortValue");
          ShortValue theValue = (ShortValue) targetClass.getValue(theValueField);
          tr.forceEarlyReturn(theValue);
        } else if ("booleanf".equals(methodName)) {
          Field theValueField = targetClass.fieldByName("ebooleanValue");
          BooleanValue theValue = (BooleanValue) targetClass.getValue(theValueField);
          tr.forceEarlyReturn(theValue);
        } else if ("stringf".equals(methodName)) {
          Field theValueField = targetClass.fieldByName("estringValue");
          StringReference theValue = (StringReference) targetClass.getValue(theValueField);
          tr.forceEarlyReturn(theValue);
        } else if ("classf".equals(methodName)) {
          Field theValueField = targetClass.fieldByName("eclassValue");
          ClassObjectReference theValue =
              (ClassObjectReference) targetClass.getValue(theValueField);
          tr.forceEarlyReturn(theValue);
        } else if ("classLoaderf".equals(methodName)) {
          Field theValueField = targetClass.fieldByName("eclassLoaderValue");
          ClassLoaderReference theValue =
              (ClassLoaderReference) targetClass.getValue(theValueField);
          tr.forceEarlyReturn(theValue);
        } else if ("threadf".equals(methodName)) {
          Field theValueField = targetClass.fieldByName("ethreadValue");
          ThreadReference theValue = (ThreadReference) targetClass.getValue(theValueField);
          tr.forceEarlyReturn(theValue);
        } else if ("threadGroupf".equals(methodName)) {
          Field theValueField = targetClass.fieldByName("ethreadGroupValue");
          ThreadGroupReference theValue =
              (ThreadGroupReference) targetClass.getValue(theValueField);
          tr.forceEarlyReturn(theValue);
        } else if ("intArrayf".equals(methodName)) {
          Field theValueField = targetClass.fieldByName("eintArrayValue");
          ArrayReference theValue = (ArrayReference) targetClass.getValue(theValueField);
          tr.forceEarlyReturn(theValue);
        } else if ("nullObjectf".equals(methodName)) {
          tr.forceEarlyReturn(null);
        } else if ("objectf".equals(methodName)) {
          Field theValueField = targetClass.fieldByName("eobjectValue");
          ObjectReference theValue = (ObjectReference) targetClass.getValue(theValueField);
          tr.forceEarlyReturn(theValue);
        } else if ("voidf".equals(methodName)) {
          VoidValue theValue = vm().mirrorOfVoid();
          tr.forceEarlyReturn(theValue);
        } else {
          failure("failure: Unknown methodName: " + origMethodName);
        }

      } catch (Exception ex) {
        failure("failure: " + ex.toString());
        ex.printStackTrace();
      }
    } else {
      System.out.println("Cannot force early return for method: " + origMethodName);
    }
  }