/** * Create a list of all methods */ public AllMethodsTestChromosomeFactory() { allMethods.addAll(TestCluster.getInstance().getTestCalls()); Randomness.shuffle(allMethods); reset(); }
private void handleReplaceCalls() { if (!hasAddedRandom && Random.wasAccessed()) { hasAddedRandom = true; try { cluster.addTestCall( new GenericMethod(Random.class.getMethod("setNextRandom", new Class<?>[] { int.class }), new GenericClass(Random.class))); } catch (SecurityException | NoSuchMethodException e) { logger.error("Error while handling Random: " + e.getMessage(), e); } } if (!hasAddedSystem && org.evosuite.runtime.System.wasTimeAccessed()) { hasAddedSystem = true; try { cluster.addTestCall( new GenericMethod(System.class.getMethod("setCurrentTimeMillis", new Class<?>[] { long.class }), new GenericClass(System.class))); } catch (SecurityException e) { logger.error("Error while handling System: " + e.getMessage(), e); } catch (NoSuchMethodException e) { logger.error("Error while handling System: " + e.getMessage(), e); } } }
private boolean hasFunctionalMocksForGenerableTypes(TestCase testCase) { for (Statement statement : testCase) { if (statement instanceof FunctionalMockStatement) { FunctionalMockStatement fm = (FunctionalMockStatement) statement; Class<?> target = fm.getTargetClass(); GenericClass gc = new GenericClass(target); if (TestCluster.getInstance().hasGenerator(gc)) { return true; } } } return false; }
/** * Helper function that is called instead of Map.containsKey * * @param o1 * a {@link java.lang.Object} object. * @param m * a {@link java.util.Map} object. * @return a int. */ public static int mapContainsKey(Map<?, ?> m, Object o1) { if(o1 != null) TestCluster.getInstance().addCastClassForContainer(o1.getClass()); return collectionContains(m.keySet(), o1); }
TestCluster cluster = TestCluster.getInstance(); GenericConstructor genericConstructor = new GenericConstructor(constructor, clazz); if (constructor.getDeclaringClass().equals(clazz)) cluster.addTestCall(genericConstructor); cluster.addGenerator(new GenericClass(clazz), // .getWithWildcardTypes(), genericConstructor); addDependencies(genericConstructor, 1); cluster.addTestCall(genericMethod); cluster.addModifier(new GenericClass(clazz), genericMethod); cluster.addGenerator(retClass, // .getWithWildcardTypes(), genericMethod); } else { cluster.addGenerator(new GenericClass(field.getGenericType()), // .getWithWildcardTypes(), genericField); logger.debug("Adding field " + field); cluster.addModifier(new GenericClass(clazz), genericField); } else { logger.debug("Is final"); && genericField.getRawGeneratedType().isAssignableFrom(actualClass)) { GenericField superClassField = new GenericField(field, clazz); cluster.addGenerator(new GenericClass(actualClass), superClassField);
GenericMethod method = new GenericMethod(m, sut); TestCluster.getInstance().addTestCall(method);
TestCluster cluster = TestCluster.getInstance(); List<GenericAccessibleObject<?>> calls = cluster.getTestCalls(); for (GenericAccessibleObject<?> call : calls) { if (!call.getDeclaringClass().getName().equals(className)) { if ((genericMethod.getName() + desc).equals(methodName)) { logger.info("Removing method " + methodName + " from cluster"); cluster.removeTestCall(call); logger.info("Testcalls left: " + cluster.getNumTestCalls()); if (("<init>" + desc).equals(methodName)) { logger.info("Removing constructor " + methodName + " from cluster"); cluster.removeTestCall(call); logger.info("Testcalls left: " + cluster.getNumTestCalls());
.filter(c -> TestCluster.getInstance().hasGenerator(c) || c.isString()) .collect(Collectors.toList()); classes.add(new GenericClass(Object.class)); GenericAccessibleObject<?> o = TestCluster.getInstance().getRandomGenerator(choice); currentRecursion.add(o); if (!TestCluster.getInstance().hasGenerator(Object.class)) { logger.debug("We have no generator for Object.class ");
private void handleSpecialCases() { if (Properties.P_REFLECTION_ON_PRIVATE > 0 && Properties.REFLECTION_START_PERCENT < 1) { // Check if we should add // PrivateAccess.callDefaultConstructorOfTheClassUnderTest() Class<?> target = Properties.getTargetClassAndDontInitialise(); Constructor<?> constructor = null; try { constructor = target.getDeclaredConstructor(); } catch (NoSuchMethodException e) { } if (constructor != null && Modifier.isPrivate(constructor.getModifiers()) && target.getDeclaredConstructors().length == 1 // Not enums && !target.isEnum()) { Method m = null; try { m = PrivateAccess.class.getDeclaredMethod("callDefaultConstructorOfTheClassUnderTest"); } catch (NoSuchMethodException e) { logger.error("Missing method: " + e.toString()); return; } GenericMethod gm = new GenericMethod(m, PrivateAccess.class); // It is not really an environment method, but not sure how else // to handle it... TestCluster.getInstance().addEnvironmentTestCall(gm); } } }
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); } } }
TestCluster.getInstance().addEnvironmentTestCall(gc); GenericClass genclass = new GenericClass(klass); TestCluster.getInstance().invalidateGeneratorCache(genclass); TestCluster.getInstance().addGenerator(genclass, gc); TestCluster.getInstance().addEnvironmentTestCall(gm); if (!returnType.equals(Void.TYPE)) { GenericClass genclass = new GenericClass(returnType); TestCluster.getInstance().invalidateGeneratorCache(genclass); TestCluster.getInstance().addGenerator(genclass, gm); addEnvironmentDependency(returnType);
protected boolean canGenerateTestsForSUT() { if (TestCluster.getInstance().getNumTestCalls() == 0) { if(Properties.P_REFLECTION_ON_PRIVATE <= 0.0 || CFGMethodAdapter.getNumMethods(TestGenerationContext.getInstance().getClassLoaderForSUT()) == 0) { return false; } } return true; } }
private boolean addAssignableClass(WildcardType wildcardType, Map<TypeVariable<?>, Type> typeMap) { Set<Class<?>> classes = TestCluster.getInstance().getAnalyzedClasses(); Set<Class<?>> assignableClasses = new LinkedHashSet<Class<?>>();
public void generateCluster(CallGraph callGraph) throws RuntimeException, ClassNotFoundException { TestCluster.setInheritanceTree(inheritanceTree); TestCluster.getInstance().removeUnusableGenerators(); logger.debug(TestCluster.getInstance().toString());
/** * Get a list of all generator objects for the type * * @param clazz * @param resolve * @return * @throws ConstructionFailedException */ public Set<GenericAccessibleObject<?>> getGenerators(GenericClass clazz, boolean resolve) throws ConstructionFailedException { // Instantiate generic type if (clazz.hasWildcardOrTypeVariables()) { GenericClass concreteClass = clazz.getGenericInstantiation(); if (!concreteClass.equals(clazz)) return getGenerators(concreteClass, false); } if (isSpecialCase(clazz)) { return getGeneratorsForSpecialCase(clazz); } if (!hasGenerator(clazz)) throw new ConstructionFailedException("No generators of type " + clazz); return generatorCache.get(clazz); }
private void gatherStatistics() { ClientServices.getInstance().getClientNode().trackOutputVariable(RuntimeVariable.Analyzed_Classes, analyzedClasses.size()); ClientServices.getInstance().getClientNode().trackOutputVariable(RuntimeVariable.Generators, TestCluster.getInstance().getGenerators().size()); ClientServices.getInstance().getClientNode().trackOutputVariable(RuntimeVariable.Modifiers, TestCluster.getInstance().getModifiers().size()); }
if(concreteClass.hasWildcardOrTypeVariables()) throw new ConstructionFailedException("Could not found concrete instantiation of generic type"); return getRandomGenerator(concreteClass); if (isSpecialCase(clazz)) { Collection<GenericAccessibleObject<?>> generators = getGeneratorsForSpecialCase(clazz); if (generators.isEmpty()) { logger.warn("No generators for class: " + clazz); if (!hasGenerator(clazz)) throw new ConstructionFailedException("No generators of type " + clazz);
r <= Properties.INSERTION_UUT && TestCluster.getInstance().getNumTestCalls() > 0 ; TestCluster.getInstance().getNumOfEnvironmentCalls() > 0; if (!success && TestCluster.getInstance().getNumTestCalls() > 0) { logger.debug("Adding new call on UUT because var was null");
(Randomness.nextDouble() < Properties.P_REFLECTION_ON_PRIVATE || TestCluster.getInstance().getNumTestCalls() == 0)){ logger.debug("Going to insert random reflection call"); return insertRandomReflectionCall(test,position, 0); GenericAccessibleObject<?> o = TestCluster.getInstance().getRandomTestCall(test); if (o == null) { logger.warn("Have no target methods to test");
/** * Update * * @param clazz */ private void addCastClassForContainer(Class<?> clazz) { if (concreteCastClasses.contains(clazz)) return; concreteCastClasses.add(clazz); // TODO: What if this is generic again? genericCastClasses.add(new GenericClass(clazz)); CastClassManager.getInstance().addCastClass(clazz, 1); TestCluster.getInstance().clearGeneratorCache(new GenericClass(clazz)); }