Java 理论与实践: 平衡测试，第 2 部分

public void addInstance(String className) {
    try {
        Class clazz = Class.forName(className);
        objectSet.add(clazz.newInstance());
    }
   catch (IllegalAccessException e) {
        logger.log("Exception in addInstance", e);
    }
    catch (InstantiationException e) {
        logger.log("Exception in addInstance", e);
    }
    catch (ClassNotFoundException e) {
        logger.log("Exception in addInstance", e);
    }
}

public void addInstance(String className) {
    try {
        Class clazz = Class.forName(className);
        objectSet.add(clazz.newInstance());
    }
    catch (Exception e) {
        logger.log("Exception in newInstance", e);
    }
}

public void addInstance(String className) {
    try {
        Class clazz = Class.forName(className);
        objectSet.add(clazz.newInstance());
    }
    catch (RuntimeException e) {
        throw e;
    }
    catch (Exception e) {
        logger.log("Exception in newInstance", e);
    }
}

public class RuntimeExceptionCapture extends BytecodeScanningDetector {
  private BugReporter bugReporter;
  private Method method;
  private OpcodeStack stack = new OpcodeStack();
  private List<ExceptionCaught> catchList;
  private List<ExceptionThrown> throwList;

  public void visitMethod(Method method) {
    this.method = method;
    super.visitMethod(method)		 }

  public void visitCode(Code obj) {
    catchList = new ArrayList<ExceptionCaught>();
    throwList = new ArrayList<ExceptionThrown>();
    stack.resetForMethodEntry(this);

    super.visitCode(obj);
    // At this point, we've identified all the catch blocks
    // More to come...
  }

  public void visit(CodeException obj) {
    super.visit(obj);
    int type = obj.getCatchType();
    if (type == 0) return;
    String name = 
      getConstantPool().constantToString(getConstantPool().getConstant(type));

    ExceptionCaught caughtException =
      new ExceptionCaught(name, obj.getStartPC(), obj.getEndPC(), obj.getHandlerPC());
    catchList.add(caughtException);
  }
}

public void sawOpcode(int seen) {
  stack.mergeJumps(this);
  try {
      switch (seen) {
      case ATHROW:
          if (stack.getStackDepth() > 0) {
              OpcodeStack.Item item = stack.getStackItem(0);
              String signature = item.getSignature();
              if (signature != null && signature.length() > 0) {
                  if (signature.startsWith("L"))
                      signature = SignatureConverter.convert(signature);
                  else
                      signature = signature.replace('/', '.');
                  throwList.add(new ExceptionThrown(signature, getPC()));
              }
          }
          break;

      case INVOKEVIRTUAL:
      case INVOKESPECIAL:
      case INVOKESTATIC:
          String className = getDottedClassConstantOperand();
          try {
              if (!className.startsWith("[")) {
                  JavaClass clazz = Repository.lookupClass(className);
                  Method[] methods = clazz.getMethods();
                  for (Method method : methods) {
                      if (method.getName().equals(getNameConstantOperand())
                              && method.getSignature().equals(getSigConstantOperand())) {
                          ExceptionTable et = method.getExceptionTable();
                          if (et != null) {
                              String[] names = et.getExceptionNames();
                              for (String name : names)
                                  throwList.add(new ExceptionThrown(name, getPC()));
                          }
                          break;
                      }
                  }
              }
          } catch (ClassNotFoundException e) {
              bugReporter.reportMissingClass(e);
          }
          break;
      default:
          break;
      }
  } finally {
      stack.sawOpcode(this, seen);
  }
}

for (ExceptionCaught caughtException : catchList) {
    Set<String> thrownSet = new HashSet<String>();
    for (ExceptionThrown thrownException : throwList) {
        if (thrownException.offset >= caughtException.startOffset
                && thrownException.offset < caughtException.endOffset) {
            thrownSet.add(thrownException.exceptionClass);
            if (thrownException.exceptionClass.equals(caughtException.exceptionClass))
                caughtException.seen = true;
        }
    }
    int catchClauses = 0;
    if (caughtException.exceptionClass.equals("java.lang.Exception") 
      && !caughtException.seen) {
        // Now we have a case where Exception is caught, but not thrown
        boolean rteCaught = false;
        for (ExceptionCaught otherException : catchList) {
            if (otherException.startOffset == caughtException.startOffset
                    && otherException.endOffset == caughtException.endOffset) {
                catchClauses++;
                if (otherException.exceptionClass.equals("java.lang.RuntimeException"))
                    rteCaught = true;
            }
        }
        int range = caughtException.endOffset - caughtException.startOffset;
        if (!rteCaught) {
            bugReporter.reportBug(new BugInstance(this, "REC_CATCH_EXCEPTION",
                    NORM_PRIORITY)
                    .addClassAndMethod(this)
                    .addSourceLine(this, caughtException.sourcePC));
        }
    }
}

if (!rteCaught) {
    int priority = LOW_PRIORITY + 1;
    if (range > 300) priority--;
    else if (range < 30) priority++;
    if (catchClauses > 1) priority++;
    if (thrownSet.size() > 1) priority--;
    if (caughtException.dead) priority--;
    bugReporter.reportBug(new BugInstance(this, "REC_CATCH_EXCEPTION",
            priority)
            .addClassAndMethod(this)
            .addSourceLine(this, caughtException.sourcePC));
}