@Override public boolean isAccessible() { return TestUsageChecker.canUse(method); }
if(isClassIncludedInPackage(c.getName(), Java9InvisiblePackage.instance.getClassesToBeIgnored())){ return false; if (!canUse(c.getEnclosingClass())) return false; if (!canUse(c.getDeclaringClass())) return false;
if (c.getDeclaringClass().isMemberClass() && !TestUsageChecker.canUse(c.getDeclaringClass())) return false; if (isForbiddenNonDeterministicCall(c)) { return false; if(!canUse(paramType)) return false;
@Override public boolean isAccessible() { return TestUsageChecker.canUse(field); }
if (!m.getReturnType().equals(String.class) && (!canUse(m.getReturnType()) || !canUse(m.getGenericReturnType()))) { return false; if(!canUse(paramType)) return false; if (isForbiddenNonDeterministicCall(m)) { return false;
@Override public boolean isAccessible() { return TestUsageChecker.canUse(constructor); }
public static boolean canUse(Field f) { return canUse(f, f.getDeclaringClass()); }
public static boolean canUse(java.lang.reflect.Type t) { if(t instanceof Class<?>) { return canUse((Class<?>) t); } else if(t instanceof ParameterizedType) { ParameterizedType pt = (ParameterizedType)t; for(java.lang.reflect.Type parameterType : pt.getActualTypeArguments()) { if(!canUse(parameterType)) return false; } if(!canUse(pt.getOwnerType())) { return false; } } // If it's not declared, let's assume it's ok return true; }
public static boolean canUse(Method m) { return canUse(m, m.getDeclaringClass()); }
@Override public boolean isAccessible() { return TestUsageChecker.canUse(type.getRawClass()); }
private void determineInspectors(Class<?> clazz) { if (!TestUsageChecker.canUse(clazz)) { inspectors.put(clazz, Collections.emptyList()); } if (!TestUsageChecker.canUse(clazz)) return; List<Inspector> inspectorList = new ArrayList<Inspector>(); for (Method method : clazz.getMethods()) { if (isInspectorMethod(method)) { // FIXXME logger.debug("Inspector for class " + clazz.getSimpleName() + ": " + method.getName() + " defined in " + method.getDeclaringClass().getCanonicalName()); inspectorList.add(new Inspector(clazz, method)); } else { logger.debug("Not an inspector: "+method.getName()); } } inspectors.put(clazz, inspectorList); }
/** * Get the set of fields defined in this class and its superclasses * * @param clazz * @return */ public static Set<Field> getAccessibleFields(Class<?> clazz) { if(accessibleFieldCache.containsKey(clazz)) { return accessibleFieldCache.get(clazz); } Set<Field> fields = new LinkedHashSet<>(); for (Field f : Reflection.getFields(clazz)) { if (TestUsageChecker.canUse(f) && !Modifier.isFinal(f.getModifiers())) { fields.add(f); } } accessibleFieldCache.put(clazz, fields); return fields; }
Constructor<?>[] allConstructors = clazz.getDeclaredConstructors(); for (Constructor<?> c : allConstructors) { if (TestUsageChecker.canUse(c)) { String methodName = "<init>" + Type.getConstructorDescriptor(c); logger.info("Adding goal for constructor " + className + "." + methodName); if (TestUsageChecker.canUse(m)) { if(clazz.isEnum()) { if (m.getName().equals("valueOf") || m.getName().equals("values")
Constructor<?>[] allConstructors = clazz.getDeclaredConstructors(); for (Constructor<?> c : allConstructors) { if (TestUsageChecker.canUse(c)) { String methodName = "<init>" + Type.getConstructorDescriptor(c); logger.info("Adding goal for constructor " + className + "." + methodName); if (TestUsageChecker.canUse(m)) { if(clazz.isEnum()) { if (m.getName().equals("valueOf") || m.getName().equals("values")
Constructor<?>[] allConstructors = clazz.getDeclaredConstructors(); for (Constructor<?> c : allConstructors) { if (TestUsageChecker.canUse(c)) { String methodName = "<init>" + Type.getConstructorDescriptor(c); logger.info("Adding goal for constructor " + className + "." + methodName); if (TestUsageChecker.canUse(m)) { if(clazz.isEnum()) { if (m.getName().equals("valueOf") || m.getName().equals("values")
try { Class<?> clazz = Class.forName(className, true, TestGenerationContext.getInstance().getClassLoaderForSUT()); if(TestUsageChecker.canUse(clazz) && !clazz.isArray()) { if(!targetClasses.contains(clazz)) targetClasses.add(clazz);
if (!f.getType().equals(String.class) && !canUse(f.getType())) { return false;
private boolean addCastClassDependencyIfAccessible(String className, Set<String> blackList) { if (className.equals(java.lang.String.class.getName())) return true; if (blackList.contains(className)) { logger.info("Cast class in blacklist: " + className); return false; } try { Class<?> clazz = TestGenerationContext.getInstance().getClassLoaderForSUT().loadClass(className); if (!TestUsageChecker.canUse(clazz)) { logger.debug("Cannot use cast class: " + className); return false; } // boolean added = addDependency(new GenericClass(clazz), 1); genericCastClasses.add(new GenericClass(clazz)); concreteCastClasses.add(clazz); blackList.add(className); return true; } catch (ClassNotFoundException e) { logger.error("Problem for " + Properties.TARGET_CLASS + ". Class not found", e); blackList.add(className); return false; } }
Class<?> subClazz = Class.forName(subClass, false, TestGenerationContext.getInstance().getClassLoaderForSUT()); if (!TestUsageChecker.canUse(subClazz)) continue; if (subClazz.isInterface())
if (TestUsageChecker.canUse(o.getClass())) { if( Proxy.isProxyClass(o.getClass()) ) { reference.setType(o.getClass().getSuperclass());