How to use

resolveType

method

in

org.jboss.arquillian.graphene.spi.TypeResolver

protected By instantiate(Class<? extends By> type, String lookup) {
  try {
    Class<? extends By> clazz = TypeResolver.resolveType(type);
    Constructor<? extends By> constructor = clazz.getConstructor(String.class);
    return constructor.newInstance(lookup);
  } catch (Exception e) {
    throw new IllegalStateException("Cannot instantiate " + type, e);
  }
}

private static By instantiate(String selector) {
  try {
    Class<? extends By> clazz = (Class<? extends By>) TypeResolver.resolveType(ByJQuery.class);
    Constructor<? extends By> constructor = clazz.getConstructor(String.class);
    return constructor.newInstance(selector);
  } catch (Exception e) {
    e.printStackTrace();
    throw new IllegalStateException("Cannot instantiate ByJQuery", e);
  }
}

private static By instantiate(String selector) {
  try {
    Class<? extends By> clazz = (Class<? extends By>) TypeResolver.resolveType(ByJQuery.class);
    Constructor<? extends By> constructor = clazz.getConstructor(String.class);
    return constructor.newInstance(selector);
  } catch (Exception e) {
    e.printStackTrace();
    throw new IllegalStateException("Cannot instantiate ByJQuery", e);
  }
}

/**
 * Resolves type based on given className, while it reflects annotation {@link ImplementedBy} in order to determine final
 * implementation of given type.
 *
 * @param typeName the name of the type
 * @return the implementation class for given type
 */
@SuppressWarnings("unchecked")
public static <T> Class<? extends T> resolveType(String typeName) {
  try {
    Class<?> clazz = Class.forName(typeName);
    return (Class<? extends T>) resolveType(clazz);
  } catch (ClassNotFoundException e) {
    throw new IllegalStateException(
        String.format(
            "Cannot find class %s. Make sure you have respective implementation (e.g. graphene-webdriver-impl.jar) included on the classpath.",
            typeName), e);
  }
}

/**
 * Resolves type based on given className, while it reflects annotation {@link ImplementedBy} in order to determine final
 * implementation of given type.
 *
 * @param typeName the name of the type
 * @return the implementation class for given type
 */
@SuppressWarnings("unchecked")
public static <T> Class<? extends T> resolveType(String typeName) {
  try {
    Class<?> clazz = Class.forName(typeName);
    return (Class<? extends T>) resolveType(clazz);
  } catch (ClassNotFoundException e) {
    throw new IllegalStateException(
        String.format(
            "Cannot find class %s. Make sure you have respective implementation (e.g. graphene-webdriver-impl.jar) included on the classpath.",
            typeName), e);
  }
}

/**
 * Instantiates a class by given implementation name
 *
 * @param className
 * @return
 */
@SuppressWarnings("unchecked")
public static <T> T instantiate(String className) {
  return (T) instantiate(resolveType(className));
}

/**
 * Instantiates a class by given implementation name
 *
 * @param className
 * @return
 */
@SuppressWarnings("unchecked")
public static <T> T instantiate(String className) {
  return (T) instantiate(resolveType(className));
}

/**
 * Instantiates class by given type, while it reflects annotation {@link ImplementedBy} in order to determine final
 * implementation of given type.
 *
 * @param type the type of the instantiated instance, which can be either final implementation type or type annotated by
 *        {@link ImplementedBy} in order to determine final implementation of given type.
 * @return instance of given type
 */
public static <T> T instantiate(Class<T> type) {
  try {
    Class<? extends T> resolvedType = resolveType(type);
    return SecurityActions.newInstance(resolvedType.getName(), new Class<?>[] {}, new Object[] {}, type);
  } catch (Exception e) {
    throw new IllegalStateException(String.format("Cannot instantiate an instance of class '%s': %s", type.getName(),
        e.getMessage()), e);
  }
}

/**
 * Instantiates class by given type, while it reflects annotation {@link ImplementedBy} in order to determine final
 * implementation of given type.
 *
 * @param type the type of the instantiated instance, which can be either final implementation type or type annotated by
 *        {@link ImplementedBy} in order to determine final implementation of given type.
 * @return instance of given type
 */
public static <T> T instantiate(Class<T> type) {
  try {
    Class<? extends T> resolvedType = resolveType(type);
    return SecurityActions.newInstance(resolvedType.getName(), new Class<?>[] {}, new Object[] {}, type);
  } catch (Exception e) {
    throw new IllegalStateException(String.format("Cannot instantiate an instance of class '%s': %s", type.getName(),
        e.getMessage()), e);
  }
}

/**
 * Resolves implementation type based on given type, while it reflects annotation {@link ImplementedBy} in order to
 * determine final implementation of given type.
 *
 * @param type the type to be resolved
 * @return the implementation class for given type
 */
@SuppressWarnings("unchecked")
public static <T> Class<? extends T> resolveType(Class<T> type) {
  ImplementedBy implementedBy = type.getAnnotation(ImplementedBy.class);
  if (implementedBy != null) {
    if (implementedBy.value() != ImplementedBy.class) {
      return (Class<? extends T>) resolveType(implementedBy.value());
    } else if (!"".equals(implementedBy.className())) {
      return (Class<? extends T>) resolveType(implementedBy.className());
    } else {
      throw new IllegalStateException(
          String.format(
              "Cannot instantiate an instance of '%s' as its %s is incomplete - it doesn't specify implementation class",
              type.getName(), implementedBy));
    }
  } else {
    return type;
  }
}

/**
 * Resolves implementation type based on given type, while it reflects annotation {@link ImplementedBy} in order to
 * determine final implementation of given type.
 *
 * @param type the type to be resolved
 * @return the implementation class for given type
 */
@SuppressWarnings("unchecked")
public static <T> Class<? extends T> resolveType(Class<T> type) {
  ImplementedBy implementedBy = type.getAnnotation(ImplementedBy.class);
  if (implementedBy != null) {
    if (implementedBy.value() != ImplementedBy.class) {
      return (Class<? extends T>) resolveType(implementedBy.value());
    } else if (!"".equals(implementedBy.className())) {
      return (Class<? extends T>) resolveType(implementedBy.className());
    } else {
      throw new IllegalStateException(
          String.format(
              "Cannot instantiate an instance of '%s' as its %s is incomplete - it doesn't specify implementation class",
              type.getName(), implementedBy));
    }
  } else {
    return type;
  }
}

InstantiationException, IllegalAccessException, IllegalArgumentException, InvocationTargetException {
Class<? extends T> clazz = TypeResolver.resolveType(type);
Class<?> outerClass = clazz.getDeclaringClass();

InstantiationException, IllegalAccessException, IllegalArgumentException, InvocationTargetException {
Class<? extends T> clazz = TypeResolver.resolveType(type);
Class<?> outerClass = clazz.getDeclaringClass();