Exemple #1
0
  static <T> T set(Class<T> interf, Object value) {
    Properties p = new Properties();
    Method ms[] = interf.getMethods();

    for (Method m : ms) {
      p.put(m.getName(), value);
    }
    return Configurable.createConfigurable(interf, (Map<Object, Object>) p);
  }
  //
  // Examine a single method to see if it raises SQLFeatureNotSupportedException.
  //
  private void vetMethod(
      Object candidate,
      Class iface,
      Method method,
      HashSet<String> unsupportedList,
      HashSet<String> notUnderstoodList)
      throws Exception {
    try {
      method.invoke(candidate, getNullArguments(method.getParameterTypes()));

      // it's ok for the method to succeed
    } catch (Throwable e) {
      if (!(e instanceof InvocationTargetException)) {
        recordUnexpectedError(candidate, iface, method, notUnderstoodList, e);
      } else {
        Throwable cause = e.getCause();

        if (cause instanceof SQLFeatureNotSupportedException) {
          boolean isExcludable = isExcludable(method);

          if (!isExcludable) {
            StackTraceElement[] stack = cause.getStackTrace();
            int i = 0;
            while (i < stack.length && !stack[i].getMethodName().equals("notImplemented")) {
              ++i;
            }
            while (i < stack.length && stack[i].getMethodName().equals("notImplemented")) {
              ++i;
            }
            if (i == stack.length) {
              // cause.printStackTrace();
            }

            unsupportedList.add(
                candidate.getClass().getName()
                    + ": "
                    + method
                    + "@"
                    + (i == stack.length ? "no source" : cause.getStackTrace()[i]));
          } else {

          }
        } else if (cause instanceof SQLException) {
          // swallow other SQLExceptions, caused by bogus args
        } else if (cause instanceof NullPointerException) {
          // swallow other NPEs, caused by bogus args
        } else if (cause instanceof ArrayIndexOutOfBoundsException) {
          // swallow these, caused by bogus args
        } else {
          recordUnexpectedError(candidate, iface, method, notUnderstoodList, cause);
        }
      }
    }
  }
 /**
  * This function instantiates an invariant class by using the <type>(PptSlice) constructor.
  *
  * @param theClass the invariant class to be instantiated
  * @param sl the PptSlice representing the variables about which an invariant is determined
  * @return an instance of the class in theClass if one can be constructed, else throw a
  *     RuntimeException
  */
 private static Invariant instantiateClass(Class<? extends Invariant> theClass, PptSlice sl) {
   try {
     Method get_proto = theClass.getMethod("get_proto", new Class<?>[] {});
     Invariant proto = (/*@Prototype*/ Invariant) get_proto.invoke(null, new Object[] {});
     Invariant inv = proto.instantiate(sl);
     return (inv);
   } catch (Exception e) {
     e.printStackTrace(System.out);
     throw new RuntimeException(
         "Error while instantiating invariant " + theClass.getName() + ": " + e.toString());
   }
 }
    /**
     * This function returns the check_modified method from the class type provided.
     *
     * @param theClass the class in which to find the check_modified method
     * @return the check_modified method if it exists
     * @throws RuntimeException if check_modified does not exist.
     */
    private static Method getCheckModified(Class<? extends Invariant> theClass) {
      Method[] methods = theClass.getMethods();

      Method currentMethod;
      for (int i = 0; i < methods.length; i++) {
        currentMethod = methods[i];
        if (currentMethod.getName().lastIndexOf("check_modified")
            != -1) { // Method should be called check_modified
          return currentMethod;
        }
      }
      throw new RuntimeException("Cannot find check_modified method");
    }
 /**
  * Checks if the invocation of the method throws a SQLExceptio as expected.
  *
  * @param LOB the Object that implements the Blob interface
  * @param method the method that needs to be tested to ensure that it throws the correct exception
  * @return true If the method throws the SQLException required after the free method has been
  *     called on the LOB object
  */
 boolean checkIfMethodThrowsSQLException(Object LOB, Method method)
     throws IllegalAccessException, InvocationTargetException {
   try {
     method.invoke(LOB, getNullValues(method.getParameterTypes()));
   } catch (InvocationTargetException ite) {
     Throwable cause = ite.getCause();
     if (cause instanceof SQLException) {
       return ((SQLException) cause).getSQLState().equals("XJ215");
     }
     throw ite;
   }
   return false;
 }
    /**
     * @return the method of invariant named by theClass that produces a String representation of
     *     the invariant.
     */
    private static Method getOutputProducer(Class<? extends Invariant> theClass) {
      Method[] methods = theClass.getMethods();

      Method currentMethod;
      for (int i = 0; i < methods.length; i++) {
        currentMethod = methods[i];

        // Method should be called format_using
        if (currentMethod.getName().lastIndexOf("format_using") != -1) {
          return currentMethod;
        }
      }
      throw new RuntimeException("Cannot find format_using method");
    }
 /**
  * @return a String representation of the invariantToTest. This String is produced by invoking
  *     the invariant's format_using with method with the argument OutputFormat.Daikon.
  */
 private static String getInvariantFormat() {
   try {
     return (String) outputProducer.invoke(invariantToTest, new Object[] {OutputFormat.DAIKON});
   } catch (Exception e) {
     throw new RuntimeException(invariantToTest + " " + outputProducer);
   }
 }
 /**
  * @return the InvariantStatus produced by invoking invariantToTest's check_modified method on
  *     the arguments represented by params.
  */
 private static InvariantStatus getCheckStatus(Object[] params) {
   try {
     return (InvariantStatus) checkModified.invoke(invariantToTest, params);
   } catch (Exception e) {
     throw new RuntimeException(" error in " + invariantToTest.getClass() + ": " + e);
   }
 }
  //
  // Returns true if this method is allowed to raise SQLFeatureNotSupportedException.
  //
  private boolean isExcludable(Method method) throws Exception {
    Class iface = method.getDeclaringClass();
    HashSet<Method> excludableMethods = excludableMap.get(iface);

    if (excludableMethods == null) {
      return false;
    }

    return excludableMethods.contains(method);
  }
  /**
   * Enumerate the methods of the Clob interface and get the list of methods present in the
   * interface
   *
   * @param LOB an instance of the Clob interface implementation
   */
  void buildMethodList(Object LOB) throws IllegalAccessException, InvocationTargetException {
    // If the given method throws the correct exception
    // set this to true and add it to the
    boolean valid = true;

    // create a list of the methods that fail the test
    Vector<Method> methodList = new Vector<Method>();

    // The class whose methods are to be verified
    Class clazz = Clob.class;

    // The list of the methods in the class that need to be invoked
    // and verified
    Method[] methods = clazz.getMethods();

    // Check each of the methods to ensure that
    // they throw the required exception
    for (int i = 0; i < methods.length; i++) {
      if (!checkIfExempted(methods[i])) {
        valid = checkIfMethodThrowsSQLException(LOB, methods[i]);

        // add the method to the list if the method does
        // not throw the required exception
        if (valid == false) methodList.add(methods[i]);

        // reset valid
        valid = true;
      }
    }

    if (!methodList.isEmpty()) {
      int c = 0;
      String failureMessage = "The Following methods don't throw " + "required exception - ";
      for (Method m : methodList) {
        c = c + 1;
        if (c == methodList.size() && c != 1) failureMessage += " & ";
        else if (c != 1) failureMessage += " , ";
        failureMessage += m.getName();
      }
      fail(failureMessage);
    }
  }
 public String toString() {
   return _method.toString();
 }