示例#1
1
  protected ArrayList createListCompletions(Package setOfCompletions) {
    ArrayList listOfCompletions = new ArrayList();

    for (Item i : setOfCompletions) {
      try {
        try {
          if (i instanceof ClassName) {
            String fullName = getFullName(setOfCompletions.getName(), ((ClassName) i).getName());
            Class clazz = getClass().getClassLoader().loadClass(fullName);
            Constructor[] ctor = clazz.getConstructors();

            for (Constructor c : ctor) {
              String cotrCompletion = createConstructorCompletion(c.toString());
              listOfCompletions.add(new BasicCompletion(defaultProvider, cotrCompletion));
            }
            listOfCompletions.add(new BasicCompletion(defaultProvider, i.getName() + "."));
          }
        } catch (NoClassDefFoundError e) {
          e.printStackTrace();
        }
      } catch (Exception e) {
        e.printStackTrace();
      }
      listOfCompletions.add(new BasicCompletion(defaultProvider, i.getName()));
    }
    return listOfCompletions;
  }
示例#2
1
  private static RetryPolicy instantiateRetryPolicy(
      String policyClassName, Object[] args, String raw) throws Exception {

    Class<?> policyClass = Class.forName(policyClassName);

    for (Constructor<?> con : policyClass.getConstructors()) {
      Class<?>[] parameterClasses = con.getParameterTypes();
      if (args.length == parameterClasses.length) {
        boolean allInts = true;
        for (Class<?> pc : parameterClasses) {
          if (!pc.equals(int.class)) {
            allInts = false;
            break;
          }
        }

        if (!allInts) {
          break;
        }

        log.debug("About to instantiate class {} with {} arguments", con.toString(), args.length);

        return (RetryPolicy) con.newInstance(args);
      }
    }

    throw new Exception(
        "Failed to identify a class matching the Astyanax Retry Policy config string \""
            + raw
            + "\"");
  }
 public static void main(String[] args) {
   if (args.length < 1) {
     print(usage);
     System.exit(0);
   }
   int lines = 0;
   try {
     Class<?> c = Class.forName(args[0]);
     Method[] methods = c.getMethods();
     Constructor[] ctors = c.getConstructors();
     if (args.length == 1) {
       for (Method method : methods) print(p.matcher(method.toString()).replaceAll(""));
       for (Constructor ctor : ctors) print(p.matcher(ctor.toString()).replaceAll(""));
       lines = methods.length + ctors.length;
     } else {
       for (Method method : methods)
         if (method.toString().indexOf(args[1]) != -1) {
           print(p.matcher(method.toString()).replaceAll(""));
           lines++;
         }
       for (Constructor ctor : ctors)
         if (ctor.toString().indexOf(args[1]) != -1) {
           print(p.matcher(ctor.toString()).replaceAll(""));
           lines++;
         }
     }
   } catch (ClassNotFoundException e) {
     print("No such class: " + e);
   }
 }
 @SuppressWarnings("unchecked")
 public final T createItem(String name, String prefix, AttributeSet attrs)
     throws ClassNotFoundException, InflateException {
   if (prefix != null) {
     name = prefix + name;
   }
   Constructor<?> constructor = GenericInflater.sConstructorMap.get(name);
   try {
     if (constructor == null) {
       if (mClassLoader == null) {
         mClassLoader = getClassLoader();
         if (mClassLoader == null) {
           mClassLoader = mContext.getClassLoader();
         }
       }
       Class<?> clazz = mClassLoader.loadClass(name);
       constructor = findConstructor(clazz);
       GenericInflater.sConstructorMap.put(clazz, constructor);
     }
     return (T) constructor.newInstance(obtainConstructorArgs(name, attrs, constructor));
   } catch (NoSuchMethodException e) {
     InflateException ie =
         new InflateException(attrs.getPositionDescription() + ": Error inflating class " + name);
     ie.initCause(e);
     throw ie;
   } catch (Exception e) {
     InflateException ie =
         new InflateException(
             attrs.getPositionDescription() + ": Error inflating class " + constructor.toString());
     ie.initCause(e);
     throw ie;
   }
 }
  /**
   * Runs the test using the specified harness.
   *
   * @param harness the test harness (<code>null</code> not permitted).
   */
  public void test(TestHarness harness) {
    // map of declared constructors which should exists
    Map<String, String> testedDeclaredConstructors = null;

    // map of declared constructors for (Open)JDK6
    Map<String, String> testedDeclaredConstructors_jdk6 = new HashMap<String, String>();

    // map of declared constructors for (Open)JDK7
    Map<String, String> testedDeclaredConstructors_jdk7 = new HashMap<String, String>();

    // map for constructors declared in (Open)JDK6
    testedDeclaredConstructors_jdk6.put(
        "public java.lang.TypeNotPresentException(java.lang.String,java.lang.Throwable)",
        "java.lang.TypeNotPresentException");

    // map for constructors declared in (Open)JDK7
    testedDeclaredConstructors_jdk7.put(
        "public java.lang.TypeNotPresentException(java.lang.String,java.lang.Throwable)",
        "java.lang.TypeNotPresentException");

    // create instance of a class TypeNotPresentException
    final Object o = new TypeNotPresentException("TypeNotPresentException", new Throwable());

    // get a runtime class of an object "o"
    final Class c = o.getClass();

    // get the right map containing constructor signatures
    testedDeclaredConstructors =
        getJavaVersion() < 7 ? testedDeclaredConstructors_jdk6 : testedDeclaredConstructors_jdk7;

    // get all declared constructors for this class
    java.lang.reflect.Constructor[] declaredConstructors = c.getDeclaredConstructors();

    // expected number of constructors
    final int expectedNumberOfConstructors = testedDeclaredConstructors.size();

    // basic check for a number of constructors
    harness.check(declaredConstructors.length, expectedNumberOfConstructors);

    // check if all declared constructors exist
    for (java.lang.reflect.Constructor declaredConstructor : declaredConstructors) {
      // constructor name should consists of package name + class name
      String constructorName = declaredConstructor.getName();
      // modifiers + package + class name + parameter types
      String constructorString = declaredConstructor.toString().replaceAll(" native ", " ");
      harness.check(testedDeclaredConstructors.containsKey(constructorString));
      harness.check(testedDeclaredConstructors.get(constructorString), constructorName);
    }
  }
示例#6
0
 /**
  * Creates the parameters needed for constructing a test class instance.
  *
  * @param finder TODO
  */
 public static Object[] createInstantiationParameters(
     Constructor ctor,
     String methodAnnotation,
     IAnnotationFinder finder,
     String[] parameterNames,
     Map<String, String> params,
     XmlSuite xmlSuite) {
   return createParameters(
       ctor.toString(),
       ctor.getParameterTypes(),
       finder.findOptionalValues(ctor),
       methodAnnotation,
       finder,
       parameterNames,
       new MethodParameters(params),
       xmlSuite);
 }
  protected ConfigurationSerializable deserializeViaCtor(
      Constructor<? extends ConfigurationSerializable> ctor, Map<String, Object> args) {
    try {
      return ctor.newInstance(args);
    } catch (Throwable ex) {
      Logger.getLogger(ConfigurationSerialization.class.getName())
          .log(
              Level.SEVERE,
              "Could not call constructor '"
                  + ctor.toString()
                  + "' of "
                  + clazz
                  + " for deserialization",
              ex instanceof InvocationTargetException ? ex.getCause() : ex);
    }

    return null;
  }
示例#8
0
 private void sendClassInfo(Class<?> clazz) {
   StringBuilder sb = new StringBuilder();
   sb.append(clazz.getName());
   sb.append("\r\n");
   sb.append("\r\n");
   for (Constructor<?> constructor : clazz.getConstructors()) {
     sb.append(constructor.toString());
     sb.append("\r\n");
   }
   sb.append("\r\n");
   for (Method method : clazz.getDeclaredMethods()) {
     sb.append(method.toString());
     sb.append("\r\n");
   }
   sb.append("\r\n");
   for (Field field : clazz.getDeclaredFields()) {
     sb.append(field.toString());
     sb.append("\r\n");
   }
   sb.append("\r\n");
   sendSupportInfo(sb.toString());
 }
示例#9
0
 /** Returns a string describing this Constructor. */
 public String toString() {
   return cons.toString();
 }
 // -------------------------------------------------------------------------
 @Override
 public String toString() {
   return constructor.toString();
 }
 /**
  * Tests that the constructor {@link FilePropertiesBundle} throws an exception to avoid being
  * called
  *
  * @author croesch
  * @since Date: Feb 19, 2011
  */
 @Test
 public void testConstructorException() {
   for (final Constructor<?> c : FilePropertiesBundle.class.getDeclaredConstructors()) {
     assertThat(c.getModifiers()).as(c.toString()).isEqualTo(2);
   }
 }