private static void initInheritanceTree(List<String> classPath) { logger.debug("Calculate inheritance hierarchy"); inheritanceTree = InheritanceTreeGenerator.createFromClassPath(classPath); TestClusterGenerator clusterGenerator = new TestClusterGenerator(inheritanceTree); TestGenerationContext.getInstance().setTestClusterGenerator(clusterGenerator); InheritanceTreeGenerator.gatherStatistics(inheritanceTree); }
private void handleCastClasses() { // If we include type seeding, then we analyze classes to find types in // instanceof and cast instructions if (Properties.SEED_TYPES) { Set<String> blackList = new LinkedHashSet<>(); initBlackListWithPrimitives(blackList); Set<String> classNames = new LinkedHashSet<>(); CastClassAnalyzer analyzer = new CastClassAnalyzer(); Map<Type, Integer> castMap = analyzer.analyze(Properties.TARGET_CLASS); for (Entry<Type, Integer> castEntry : castMap.entrySet()) { String className = castEntry.getKey().getClassName(); if (blackList.contains(className)) continue; if (addCastClassDependencyIfAccessible(className, blackList)) { CastClassManager.getInstance().addCastClass(className, castEntry.getValue()); classNames.add(castEntry.getKey().getClassName()); } } // If SEED_TYPES is false, only Object is a cast class // logger.info("Handling cast classes"); // addCastClasses(classNames, blackList); logger.debug("Cast classes used: " + classNames); } }
private void addDeclaredClasses(Set<Class<?>> targetClasses, Class<?> currentClass) { for (Class<?> c : currentClass.getDeclaredClasses()) { logger.info("Adding declared class " + c); targetClasses.add(c); addDeclaredClasses(targetClasses, c); } }
private void addInjectionDependencies(Set<String> blackList) { Set<Class<?>> toAdd = new LinkedHashSet<>(); try { analyzedClasses.stream().flatMap(c -> Injector.getAllFieldsToInject(c).stream()).map(f -> f.getType()) .forEach(t -> addInjectionRecursively(t, toAdd, blackList)); } catch(Throwable t) { logger.warn("Error during initialisation of injection dependencies: "+t+", continuing anyway."); } toAdd.stream().forEach(c -> dependencies.add(new DependencyPair(0, new GenericClass(c).getRawClass()))); resolveDependencies(blackList); }
initBlackListWithEvoSuitePrimitives(blackList); handleCastClasses(); initializeTargetMethods(); resolveDependencies(blackList); handleSpecialCases(); addInjectionDependencies(blackList); gatherStatistics();
addDeclaredClasses(targetClasses, targetClass); if ((!targetClass.isInterface() && Modifier.isAbstract(targetClass.getModifiers())) || isInterfaceWithDefaultMethods(targetClass)) { logger.info("SUT is an abstract class"); addDependencies(genericConstructor, 1); logger.debug("Keeping track of " + constructor.getDeclaringClass().getName() + "." + constructor.getName() + org.objectweb.asm.Type.getConstructorDescriptor(constructor)); addDependencies(genericMethod, 1); GenericClass retClass = new GenericClass(method.getReturnType()); addDependencies(genericMethod, 1); addDependencies(genericField, 1); cluster.addGenerator(new GenericClass(field.getGenericType()), // .getWithWildcardTypes(), genericField); logger.debug("Adding field " + field); final boolean isFinalField = isFinalField(field); if (!isFinalField) { logger.debug("Is not final"); ) { GenericField genericField = new GenericField(field, clazz); addDependencies(genericField, 1); if (!isFinalField(field)) { logger.debug("Is not final");
testClusterGenerator = new TestClusterGenerator( DependencyAnalysis.getInheritanceTree()); testClusterGenerator.generateCluster(DependencyAnalysis.getCallGraph()); } catch (RuntimeException e) { logger.error(e.getMessage(), e);
private void addDependencies(GenericConstructor constructor, int recursionLevel) { if (recursionLevel > Properties.CLUSTER_RECURSION) { logger.debug("Maximum recursion level reached, not adding dependencies of {}", constructor); return; } if (dependencyCache.contains(constructor)) { return; } logger.debug("Analyzing dependencies of " + constructor); dependencyCache.add(constructor); for (java.lang.reflect.Type parameterClass : constructor.getRawParameterTypes()) { logger.debug("Adding dependency " + parameterClass); addDependency(new GenericClass(parameterClass), recursionLevel); } }
addDependencies(genericConstructor, recursionLevel + 1); if (logger.isDebugEnabled()) { logger.debug("Keeping track of " + constructor.getDeclaringClass().getName() + "." addDependencies(genericMethod, recursionLevel + 1); if (!Properties.PURE_INSPECTORS) { cluster.addModifier(new GenericClass(clazz), genericMethod); final boolean isFinalField = isFinalField(field); if (!isFinalField) { addDependencies(genericField, recursionLevel + 1);
private void addEnvironmentDependency(Class<?> klass) { if (handledClasses.contains(klass.getCanonicalName()) || !TestClusterUtils.isEvoSuiteClass(klass)) { return; // already handled, or not valid } handledClasses.add(klass.getCanonicalName()); boolean excludeClass = klass.getAnnotation(EvoSuiteClassExclude.class) != null; // do not consider constructors for (Method m : klass.getMethods()) { if (shouldSkip(excludeClass, m)) { continue; } GenericAccessibleObject gm = new GenericMethod(m, klass); GenericClass gc = new GenericClass(klass); TestCluster.getInstance().addModifier(gc, gm); testClusterGenerator.addNewDependencies(Arrays.asList(m.getParameterTypes())); Class<?> returnType = m.getReturnType(); if (!returnType.equals(Void.TYPE)) { GenericClass genclass = new GenericClass(returnType); TestCluster.getInstance().invalidateGeneratorCache(genclass); TestCluster.getInstance().addGenerator(genclass, gm); addEnvironmentDependency(returnType); } } }
private void addInjectionRecursively(Class<?> target, Set<Class<?>> toAdd, Set<String> blackList) { if (toAdd.contains(target) || blackList.contains(target.getName())) { return; } toAdd.add(target); for (Field f : Injector.getAllFieldsToInject(target)) { addInjectionRecursively(f.getType(), toAdd, blackList); } }
added = addDependencyClass(dependency.getDependencyClass(), dependency.getRecursion()); if (!added) { blackList.add(className);
private void addDependencies(GenericField field, int recursionLevel) { if (recursionLevel > Properties.CLUSTER_RECURSION) { logger.debug("Maximum recursion level reached, not adding dependencies of {}", field); return; } if (dependencyCache.contains(field)) { return; } if (field.getField().getType().isPrimitive() || field.getField().getType().equals(String.class)) return; logger.debug("Analyzing dependencies of " + field); dependencyCache.add(field); logger.debug("Adding dependency " + field.getName()); addDependency(new GenericClass(field.getGenericFieldType()), recursionLevel); }
TestCluster.getInstance().addGenerator(genclass, gc); testClusterGenerator.addNewDependencies(Arrays.asList(c.getParameterTypes())); TestCluster.getInstance().addEnvironmentTestCall(gm); testClusterGenerator.addNewDependencies(Arrays.asList(m.getParameterTypes()));
/** * As RESET_STATIC_FINAL_FIELDS=true removes the <code>final</code> modifier * of static fields in the target class, the purpose of this test case is to * check that the TestClusterGenerator indeed does not include these fields. * * * @throws ClassNotFoundException * @throws RuntimeException */ @Test public void test() throws ClassNotFoundException, RuntimeException { Properties.TARGET_CLASS = FinalPrimitiveField.class.getCanonicalName(); Properties.RESET_STATIC_FINAL_FIELDS = true; ClassPathHandler.getInstance().changeTargetCPtoTheSameAsEvoSuite(); String cp = ClassPathHandler.getInstance().getTargetProjectClasspath(); DependencyAnalysis.analyzeClass(Properties.TARGET_CLASS, Arrays.asList(cp.split(File.pathSeparator))); InheritanceTree tree = DependencyAnalysis.getInheritanceTree(); TestClusterGenerator gen = new TestClusterGenerator(tree); assertNotNull(gen); TestCluster cluster = TestCluster.getInstance(); List<GenericAccessibleObject<?>> testCalls = cluster.getTestCalls(); assertEquals("Unexpected number of TestCalls", 2, testCalls.size()); }
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<?> mock = MockList.getMockClass(clazz.getRawClass().getCanonicalName()); if (mock != null) { clusterGenerator.addNewDependencies(Arrays.asList(mock)); } else { clusterGenerator.addNewDependencies(Arrays.asList(clazz.getRawClass()));
/** * As RESET_STATIC_FINAL_FIELDS=true removes the <code>final</code> modifier * of static fields in the target class, the purpose of this test case is to * check that the TestClusterGenerator indeed does not include these fields. * * * @throws ClassNotFoundException * @throws RuntimeException */ @Test public void test() throws ClassNotFoundException, RuntimeException { Properties.TARGET_CLASS = FinalReferenceField.class.getCanonicalName(); Properties.RESET_STATIC_FINAL_FIELDS = true; ClassPathHandler.getInstance().changeTargetCPtoTheSameAsEvoSuite(); String cp = ClassPathHandler.getInstance().getTargetProjectClasspath(); DependencyAnalysis.analyzeClass(Properties.TARGET_CLASS, Arrays.asList(cp.split(File.pathSeparator))); InheritanceTree tree = DependencyAnalysis.getInheritanceTree(); TestClusterGenerator gen = new TestClusterGenerator(tree); assertNotNull(gen); TestCluster cluster = TestCluster.getInstance(); List<GenericAccessibleObject<?>> testCalls = cluster.getTestCalls(); assertEquals("Unexpected number of TestCalls", 2, testCalls.size()); }
private void addDependencies(GenericMethod method, int recursionLevel) { if (recursionLevel > Properties.CLUSTER_RECURSION) { logger.debug("Maximum recursion level reached, not adding dependencies of {}", method); return; } if (dependencyCache.contains(method)) { return; } logger.debug("Analyzing dependencies of " + method); dependencyCache.add(method); for (java.lang.reflect.Type parameter : method.getRawParameterTypes()) { logger.debug("Current parameter " + parameter); GenericClass parameterClass = new GenericClass(parameter); if (parameterClass.isPrimitive() || parameterClass.isString()) continue; logger.debug("Adding dependency " + parameterClass.getClassName()); addDependency(parameterClass, recursionLevel); } // If mocking is enabled, also return values are dependencies // as we might attempt to mock the method // // Only look at the return values of direct dependencies as the // number of dependencies otherwise might explode if (Properties.P_FUNCTIONAL_MOCKING > 0 && recursionLevel == 1) { GenericClass returnClass = method.getGeneratedClass(); if (!returnClass.isPrimitive() && !returnClass.isString()) addDependency(returnClass, recursionLevel); } }
addDependency(new GenericClass(clazz.getComponentType()), recursionLevel); return;