/** * 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); }
/** * Helper function that is called instead of Map.containsValue * * @param o1 * a {@link java.lang.Object} object. * @param m * a {@link java.util.Map} object. * @return a int. */ public static int mapContainsValue(Map<?, ?> m, Object o1) { if(o1 != null) TestCluster.getInstance().addCastClassForContainer(o1.getClass()); return collectionContains(m.values(), o1); }
/** * Create a list of all methods */ public AllMethodsTestChromosomeFactory() { allMethods.addAll(TestCluster.getInstance().getTestCalls()); Randomness.shuffle(allMethods); reset(); }
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); } } }
/** * 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)); }
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); } } }
/** * If System.in was used, add methods to handle/simulate it */ private void handleSystemIn() { if (!hasAddedSystemIn && SystemInUtil.getInstance().hasBeenUsed()) { hasAddedSystemIn = true; try { TestCluster.getInstance() .addEnvironmentTestCall(new GenericMethod( SystemInUtil.class.getMethod("addInputLine", new Class<?>[] { String.class }), new GenericClass(SystemInUtil.class))); } catch (SecurityException e) { logger.error("Error while handling Random: " + e.getMessage(), e); } catch (NoSuchMethodException e) { logger.error("Error while handling Random: " + 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; }
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()); }
@Test public void testTestCalls() throws ConstructionFailedException, NoSuchMethodException, SecurityException { List<GenericAccessibleObject<?>> testCalls = TestCluster.getInstance().getTestCalls(); System.out.println(testCalls.toString()); assertEquals("Expected 5 test calls, but got: " + testCalls.size() + ": " + testCalls, 4, testCalls.size()); }
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; } }
TestCluster.getInstance().removeUnusableGenerators(); logger.debug(TestCluster.getInstance().toString());
@Override public void run() { changeState(ClientState.STARTED); Sandbox.goingToExecuteSUTCode(); TestGenerationContext.getInstance().goingToExecuteSUTCode(); Sandbox.goingToExecuteUnsafeCodeOnSameThread(); try { LoggingUtils.getEvoLogger().info("* Analyzing classpath (dependency analysis)"); DependencyAnalysis.analyzeClass(Properties.TARGET_CLASS, Arrays.asList(ClassPathHandler.getInstance().getClassPathElementsForTargetProject())); StringBuffer fileNames = new StringBuffer(); for(Class<?> clazz : TestCluster.getInstance().getAnalyzedClasses()) { fileNames.append(clazz.getName()); fileNames.append("\n"); } LoggingUtils.getEvoLogger().info("* Writing class dependencies to file "+fileName); FileIOUtils.writeFile(fileNames.toString(), fileName); } catch (Throwable t) { logger.error("Error when analysing coverage for: " + Properties.TARGET_CLASS + " with seed " + Randomness.getSeed() + ". Configuration id : " + Properties.CONFIGURATION_ID, t); } finally { Sandbox.doneWithExecutingUnsafeCodeOnSameThread(); Sandbox.doneWithExecutingSUTCode(); TestGenerationContext.getInstance().doneWithExecutingSUTCode(); } changeState(ClientState.DONE); } });
@Test public void test() throws Exception { String targetClass = ClassToCheckGenerators.class.getName(); Properties.TARGET_CLASS = targetClass; List<String> classpath = new ArrayList<>(); String cp = System.getProperty("user.dir") + "/target/test-classes"; classpath.add(cp); ClassPathHandler.getInstance().addElementToTargetProjectClassPath(cp); ClassPathHandler.getInstance().changeTargetCPtoTheSameAsEvoSuite(); DependencyAnalysis.analyzeClass(targetClass, classpath); ClassLoader cl = TestGenerationContext.getInstance().getClassLoaderForSUT(); //WithGenerator has default constructor Assert.assertTrue(TestCluster.getInstance().hasGenerator(cl.loadClass(WithGenerator.class.getName()))); //Only generator for IX is GeneratorForX, but this latter has no generator itself Assert.assertFalse(TestCluster.getInstance().hasGenerator(cl.loadClass(IX.class.getName()))); //Special case of recursion Assert.assertFalse(TestCluster.getInstance().hasGenerator(cl.loadClass(IGeneratorForItself.class.getName()))); //same for abstract versions Assert.assertFalse(TestCluster.getInstance().hasGenerator(cl.loadClass(AX.class.getName()))); Assert.assertFalse(TestCluster.getInstance().hasGenerator(cl.loadClass(AGeneratorForItself.class.getName()))); //be sure it has no generator Assert.assertFalse(TestCluster.getInstance().hasGenerator(cl.loadClass(GeneratorForX.class.getName()))); //even for concrete versions it should not work, as they all have private constructors Assert.assertFalse(TestCluster.getInstance().hasGenerator(cl.loadClass(X.class.getName()))); Assert.assertFalse(TestCluster.getInstance().hasGenerator(cl.loadClass(GeneratorForItself.class.getName()))); }
if(TestCluster.getInstance().getNumTestCalls() > 0) { logger.debug("Adding new call on UUT because var was null"); success = TestFactory.getInstance().insertRandomCall(test, position);
@Test public void testCycle() throws Exception { String targetClass = ClassToCheckGetterOfInput.class.getName(); Properties.TARGET_CLASS = targetClass; List<String> classpath = new ArrayList<>(); String cp = System.getProperty("user.dir") + "/target/test-classes"; classpath.add(cp); ClassPathHandler.getInstance().addElementToTargetProjectClassPath(cp); ClassPathHandler.getInstance().changeTargetCPtoTheSameAsEvoSuite(); DependencyAnalysis.analyzeClass(targetClass, classpath); ClassLoader cl = TestGenerationContext.getInstance().getClassLoaderForSUT(); Assert.assertFalse(TestCluster.getInstance().hasGenerator(cl.loadClass(AnInterface.class.getName()))); } }
/** * 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()); }
/** * 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 TestSuiteChromosome generateTests() { // Make sure target class is loaded at this point TestCluster.getInstance(); ContractChecker checker = null; if (Properties.CHECK_CONTRACTS) { checker = new ContractChecker(); TestCaseExecutor.getInstance().addObserver(checker); } TestGenerationStrategy strategy = TestSuiteGeneratorHelper.getTestGenerationStrategy(); TestSuiteChromosome testSuite = strategy.generateTests(); if (Properties.CHECK_CONTRACTS) { TestCaseExecutor.getInstance().removeObserver(checker); } StatisticsSender.executedAndThenSendIndividualToMaster(testSuite); TestSuiteGeneratorHelper.getBytecodeStatistics(); ClientServices.getInstance().getClientNode().publishPermissionStatistics(); writeObjectPool(testSuite); /* * PUTGeneralizer generalizer = new PUTGeneralizer(); for (TestCase test * : tests) { generalizer.generalize(test); // ParameterizedTestCase put * = new ParameterizedTestCase(test); } */ return testSuite; }
clazz.isString() || clazz.isArray() || TestCluster.getInstance().hasGenerator(parameterType) || Properties.P_FUNCTIONAL_MOCKING > 0 || Properties.MOCK_IF_NO_GENERATOR) {