Examples with MethodStatement org.evosuite.testcase.MethodStatement used on opensource projects

Example 1 with MethodStatement

use of org.evosuite.testcase.MethodStatement in project evosuite by EvoSuite.

the class SearchStatistics method minimized.

/**
 * {@inheritDoc}
 */
@Override
public void minimized(Chromosome chromosome) {
    TestSuiteChromosome best = (TestSuiteChromosome) chromosome;
    StatisticEntry entry = statistics.get(statistics.size() - 1);
    entry.tests = best.getTests();
    // TODO: Remember which lines were covered
    // This information is in ExecutionTrace.coverage
    entry.size_minimized = best.size();
    entry.length_minimized = best.totalLengthOfTestCases();
    entry.minimized_time = System.currentTimeMillis();
    entry.coverage = new HashSet<Integer>();
    entry.coveredIntraMethodPairs = 0;
    entry.coveredInterMethodPairs = 0;
    entry.coveredIntraClassPairs = 0;
    entry.coveredParameterPairs = 0;
    entry.aliasingIntraMethodPairs = 0;
    entry.aliasingInterMethodPairs = 0;
    entry.aliasingIntraClassPairs = 0;
    entry.aliasingParameterPairs = 0;
    entry.coveredAliasIntraMethodPairs = 0;
    entry.coveredAliasInterMethodPairs = 0;
    entry.coveredAliasIntraClassPairs = 0;
    entry.coveredAliasParameterPairs = 0;
    // TODO isn't this more or less copy-paste of
    // BranchCoverageSuiteFitness.getFitness()?
    // DONE To make this work for other criteria too, it would be perfect if
    // one
    // could ask every suite fitness how many goals were covered
    logger.debug("Calculating coverage of best individual with fitness " + chromosome.getFitness());
    Map<Integer, Double> true_distance = new HashMap<Integer, Double>();
    Map<Integer, Double> false_distance = new HashMap<Integer, Double>();
    Map<Integer, Integer> predicate_count = new HashMap<Integer, Integer>();
    Set<String> covered_methods = new HashSet<String>();
    Map<String, Set<Class<?>>> implicitTypesOfExceptions = new HashMap<String, Set<Class<?>>>();
    Map<String, Set<Class<?>>> explicitTypesOfExceptions = new HashMap<String, Set<Class<?>>>();
    Map<TestCase, Map<Integer, Boolean>> isExceptionExplicit = new HashMap<TestCase, Map<Integer, Boolean>>();
    Set<DefUseCoverageTestFitness> coveredDUGoals = new HashSet<DefUseCoverageTestFitness>();
    if (ArrayUtil.contains(Properties.CRITERION, Properties.Criterion.DEFUSE) || Properties.ANALYSIS_CRITERIA.toUpperCase().contains("DEFUSE")) {
        for (DefUseCoverageTestFitness goal : DefUseCoverageFactory.getDUGoals()) {
            if (goal.isInterMethodPair())
                entry.numInterMethodPairs++;
            else if (goal.isIntraClassPair())
                entry.numIntraClassPairs++;
            else if (goal.isParameterGoal())
                entry.numParameterPairs++;
            else
                entry.numIntraMethodPairs++;
            if (goal.isAlias()) {
                if (goal.isInterMethodPair())
                    entry.aliasingInterMethodPairs++;
                else if (goal.isIntraClassPair())
                    entry.aliasingIntraClassPairs++;
                else if (goal.isParameterGoal())
                    entry.aliasingParameterPairs++;
                else
                    entry.aliasingIntraMethodPairs++;
            }
        }
        entry.numDefinitions = DefUsePool.getDefCounter();
        entry.numUses = DefUsePool.getUseCounter();
        entry.numDefUsePairs = DefUseCoverageFactory.getDUGoals().size();
    }
    logger.debug("Calculating line coverage");
    for (TestChromosome test : best.tests) {
        ExecutionResult result = executeTest(test, entry.className);
        ExecutionTrace trace = result.getTrace();
        entry.coverage.addAll(getCoveredLines(trace, entry.className));
        isExceptionExplicit.put(test.getTestCase(), result.explicitExceptions);
        if (ArrayUtil.contains(Properties.CRITERION, Properties.Criterion.DEFUSE) || Properties.ANALYSIS_CRITERIA.toUpperCase().contains("DEFUSE")) {
            for (DefUseCoverageTestFitness goal : DefUseCoverageFactory.getDUGoals()) {
                if (coveredDUGoals.contains(goal))
                    continue;
                if (goal.isCovered(result)) {
                    coveredDUGoals.add(goal);
                    if (goal.isInterMethodPair()) {
                        entry.coveredInterMethodPairs++;
                        if (goal.isAlias()) {
                            entry.coveredAliasInterMethodPairs++;
                        }
                    } else if (goal.isIntraClassPair()) {
                        entry.coveredIntraClassPairs++;
                        if (goal.isAlias()) {
                            entry.coveredAliasIntraClassPairs++;
                        }
                    } else if (goal.isParameterGoal()) {
                        entry.coveredParameterPairs++;
                        if (goal.isAlias()) {
                            entry.coveredAliasParameterPairs++;
                        }
                    } else {
                        entry.coveredIntraMethodPairs++;
                        if (goal.isAlias()) {
                            entry.coveredAliasIntraMethodPairs++;
                        }
                    }
                }
            }
        }
        for (String method : trace.getCoveredMethods()) {
            if (method.startsWith(Properties.TARGET_CLASS) || method.startsWith(Properties.TARGET_CLASS + '$'))
                covered_methods.add(method);
        }
        for (Entry<Integer, Double> e : trace.getTrueDistances().entrySet()) {
            if (!predicate_count.containsKey(e.getKey()))
                predicate_count.put(e.getKey(), 1);
            else
                predicate_count.put(e.getKey(), predicate_count.get(e.getKey()) + 1);
            if (!true_distance.containsKey(e.getKey()) || true_distance.get(e.getKey()) > e.getValue()) {
                true_distance.put(e.getKey(), e.getValue());
            }
        }
        for (Entry<Integer, Double> e : trace.getFalseDistances().entrySet()) {
            if (!predicate_count.containsKey(e.getKey()))
                predicate_count.put(e.getKey(), 1);
            else
                predicate_count.put(e.getKey(), predicate_count.get(e.getKey()) + 1);
            if (!false_distance.containsKey(e.getKey()) || false_distance.get(e.getKey()) > e.getValue()) {
                false_distance.put(e.getKey(), e.getValue());
            }
        }
    }
    for (TestCase test : entry.results.keySet()) {
        Map<Integer, Throwable> exceptions = entry.results.get(test);
        // iterate on the indexes of the statements that resulted in an exception
        for (Integer i : exceptions.keySet()) {
            Throwable t = exceptions.get(i);
            if (t instanceof SecurityException && Properties.SANDBOX)
                continue;
            if (i >= test.size()) {
                // Timeouts are put after the last statement if the process was forcefully killed
                continue;
            }
            String methodName = "";
            boolean sutException = false;
            if (test.getStatement(i) instanceof MethodStatement) {
                MethodStatement ms = (MethodStatement) test.getStatement(i);
                Method method = ms.getMethod().getMethod();
                methodName = method.getName() + Type.getMethodDescriptor(method);
                if (method.getDeclaringClass().equals(Properties.getTargetClass()))
                    sutException = true;
            } else if (test.getStatement(i) instanceof ConstructorStatement) {
                ConstructorStatement cs = (ConstructorStatement) test.getStatement(i);
                Constructor<?> constructor = cs.getConstructor().getConstructor();
                methodName = "<init>" + Type.getConstructorDescriptor(constructor);
                if (constructor.getDeclaringClass().equals(Properties.getTargetClass()))
                    sutException = true;
            }
            boolean notDeclared = !test.getStatement(i).getDeclaredExceptions().contains(t.getClass());
            if (notDeclared && sutException) {
                /*
					 * we need to distinguish whether it is explicit (ie "throw" in the code, eg for validating
					 * input for pre-condition) or implicit ("likely" a real fault).
					 */
                /*
					 * FIXME: need to find a way to calculate it
					 */
                boolean isExplicit = isExceptionExplicit.get(test).containsKey(i) && isExceptionExplicit.get(test).get(i);
                if (isExplicit) {
                    if (!explicitTypesOfExceptions.containsKey(methodName))
                        explicitTypesOfExceptions.put(methodName, new HashSet<Class<?>>());
                    explicitTypesOfExceptions.get(methodName).add(t.getClass());
                } else {
                    if (!implicitTypesOfExceptions.containsKey(methodName))
                        implicitTypesOfExceptions.put(methodName, new HashSet<Class<?>>());
                    implicitTypesOfExceptions.get(methodName).add(t.getClass());
                }
            }
        }
    }
    int num_covered = 0;
    entry.error_branches = BranchPool.getNumArtificialBranches();
    for (Integer key : predicate_count.keySet()) {
        // logger.info("Key: "+key);
        double df = true_distance.get(key);
        double dt = false_distance.get(key);
        Branch b = BranchPool.getBranch(key);
        if (!b.getClassName().startsWith(Properties.TARGET_CLASS) && !b.getClassName().startsWith(Properties.TARGET_CLASS + '$'))
            continue;
        // if (!b.isInstrumented()) {
        if (df == 0.0)
            num_covered++;
        if (dt == 0.0)
            num_covered++;
        // }
        if (b.isInstrumented()) {
            // entry.error_branches++;
            if (df == 0.0)
                entry.error_branches_covered++;
            if (dt == 0.0)
                entry.error_branches_covered++;
        }
    }
    for (String methodName : CFGMethodAdapter.getMethodsPrefix(Properties.TARGET_CLASS)) {
        boolean allArtificial = true;
        int splitPoint = methodName.lastIndexOf(".");
        String cName = methodName.substring(0, splitPoint);
        String mName = methodName.substring(splitPoint + 1);
        boolean hasBranches = false;
        for (Branch b : BranchPool.retrieveBranchesInMethod(cName, mName)) {
            hasBranches = true;
            if (!b.isInstrumented()) {
                allArtificial = false;
                break;
            }
        }
        if (hasBranches && allArtificial) {
            entry.error_branchless_methods++;
            if (covered_methods.contains(methodName)) {
                entry.error_branchless_methods_covered++;
            }
        }
    }
    int coveredBranchlessMethods = 0;
    for (String branchlessMethod : BranchPool.getBranchlessMethodsMemberClasses(Properties.TARGET_CLASS)) {
        if (covered_methods.contains(branchlessMethod))
            coveredBranchlessMethods++;
    }
    // + covered branchless methods?
    entry.covered_branches = num_covered;
    entry.covered_methods = covered_methods.size();
    entry.covered_branchless_methods = coveredBranchlessMethods;
    // BranchCoverageSuiteFitness f = new BranchCoverageSuiteFitness();
    /*
		if (Properties.CRITERION == Properties.Criterion.DEFUSE
		        || Properties.ANALYSIS_CRITERIA.contains("DefUse")) {
			entry.coveredIntraMethodPairs = DefUseCoverageSuiteFitness.mostCoveredGoals.get(DefUsePairType.INTRA_METHOD);
			entry.coveredInterMethodPairs = DefUseCoverageSuiteFitness.mostCoveredGoals.get(DefUsePairType.INTER_METHOD);
			entry.coveredIntraClassPairs = DefUseCoverageSuiteFitness.mostCoveredGoals.get(DefUsePairType.INTRA_CLASS);
			entry.coveredParameterPairs = DefUseCoverageSuiteFitness.mostCoveredGoals.get(DefUsePairType.PARAMETER);
		}
			*/
    // System.out.println(covered_methods);
    // DONE make this work for other criteria too. this will only work for
    // branch coverage - see searchStarted()/Finished()
    // entry.total_goals = 2 * entry.total_branches +
    // entry.branchless_methods; - moved to searchStarted()
    // entry.covered_goals = num_covered; - moved to searchFinished()
    // for(String e : CFGMethodAdapter.branchless_methods) {
    // for (String e : CFGMethodAdapter.methods) {
    // for (String e : BranchPool.getBranchlessMethods()) {
    // if (covered_methods.contains(e)) {
    // logger.info("Covered method: " + e);
    // entry.covered_goals++;
    // } else {
    // logger.info("Method is not covered: " + e);
    // }
    /*
		 * logger.debug("Covered methods: " + covered_methods.size() + "/" +
		 * entry.total_methods); for (String method : covered_methods) {
		 * logger.debug("Covered method: " + method); }
		 */
    // }
    String s = calculateCoveredBranchesBitString(best);
    entry.goalCoverage = s;
    entry.explicitMethodExceptions = getNumExceptions(explicitTypesOfExceptions);
    entry.explicitTypeExceptions = getNumClassExceptions(explicitTypesOfExceptions);
    entry.implicitMethodExceptions = getNumExceptions(implicitTypesOfExceptions);
    entry.implicitTypeExceptions = getNumClassExceptions(implicitTypesOfExceptions);
    entry.implicitExceptions = implicitTypesOfExceptions;
    entry.explicitExceptions = explicitTypesOfExceptions;
}

Example 2 with MethodStatement

use of org.evosuite.testcase.MethodStatement in project evosuite by EvoSuite.

the class TestExtractingVisitor method endVisit.

/**
 * {@inheritDoc}
 */
@SuppressWarnings("unchecked")
@Override
public void endVisit(MethodInvocation methodInvocation) {
    // TODO If in constructor, treat calls to this() and super().
    String methodName = methodInvocation.getName().toString();
    if (methodName.equals("fail") || methodName.startsWith("assert")) {
        logger.warn("We are ignoring fail and assert statements for now.");
        for (Expression expression : (List<Expression>) methodInvocation.arguments()) {
            if ((expression instanceof MethodInvocation) || (expression instanceof ClassInstanceCreation)) {
                assert !nestedCallResults.isEmpty();
                nestedCallResults.pop();
            }
        }
        return;
    }
    IMethodBinding methodBinding = methodInvocation.resolveMethodBinding();
    if (methodBinding == null) {
        throw new RuntimeException("JDT was unable to resolve method for " + methodInvocation);
    }
    List<?> paramTypes = Arrays.asList(methodBinding.getParameterTypes());
    List<VariableReference> params = convertParams(methodInvocation.arguments(), paramTypes);
    Method method = retrieveMethod(methodInvocation, methodBinding, params);
    /*
		Class<?> declaringClass = method.getDeclaringClass();
		if (false) {
			// TODO Methods can be declared in an order such that the called
			// method is not yet read
			if (testCase.getClassName().equals(declaringClass.getName())
			        || testCase.isDescendantOf(declaringClass)) {
				MethodDef methodDef = testCase.getMethod(method.getName());
				VariableReference retVal = retrieveResultReference(methodInvocation);
				retVal.setOriginalCode(methodInvocation.toString());
				testCase.convertMethod(methodDef, params, retVal);
				return;
			}
		}
		*/
    VariableReference callee = null;
    if (!Modifier.isStatic(method.getModifiers())) {
        callee = retrieveCalleeReference(methodInvocation);
    }
    MethodStatement methodStatement = null;
    ASTNode parent = methodInvocation.getParent();
    if (parent instanceof ExpressionStatement) {
        VariableReference retVal = new ValidVariableReference(testCase.getReference(), method.getReturnType());
        retVal.setOriginalCode(methodInvocation.toString());
        methodStatement = new ValidMethodStatement(testCase.getReference(), method, callee, retVal, params);
        testCase.addStatement(methodStatement);
        return;
    }
    VariableReference retVal = retrieveResultReference(methodInvocation);
    retVal.setOriginalCode(methodInvocation.toString());
    methodStatement = new ValidMethodStatement(testCase.getReference(), method, callee, retVal, params);
    if (!(parent instanceof Block)) {
        nestedCallResults.push(retVal);
    }
    testCase.addStatement(methodStatement);
}

Example 3 with MethodStatement

use of org.evosuite.testcase.MethodStatement in project evosuite by EvoSuite.

the class TestCaseCodeGenerator method createUnobservedInitStmt.

@SuppressWarnings({ "unchecked", "rawtypes" })
private void createUnobservedInitStmt(final int logRecNo, final TestCase testCase) {
    // NOTE: PLAIN INIT: has always one non-null param
    // TODO: use primitives
    final int oid = this.log.objectIds.get(logRecNo);
    final String type = this.log.oidClassNames.get(this.log.oidRecMapping.get(oid));
    try {
        // Class.forName("com.thoughtworks.xstream.XStream", true, StaticTestCluster.classLoader);
        final Class<?> xStreamType = getClassForName("com.thoughtworks.xstream.XStream");
        // Class.forName(type, true, StaticTestCluster.classLoader);
        final Class<?> typeClass = getClassForName(type);
        final Object value = this.log.params.get(logRecNo)[0];
        if (xStreamRef == null) {
            final ConstructorStatement constr = new ConstructorStatement(testCase, new GenericConstructor(xStreamType.getConstructor(new Class<?>[0]), xStreamType), Collections.EMPTY_LIST);
            xStreamRef = testCase.addStatement(constr);
        }
        // Class.forName("java.lang.String", true, StaticTestCluster.classLoader);
        final Class<?> stringType = getClassForName("java.lang.String");
        final PrimitiveStatement stringRep = PrimitiveStatement.getPrimitiveStatement(testCase, stringType);
        stringRep.setValue(value);
        final VariableReference stringRepRef = testCase.addStatement(stringRep);
        final MethodStatement m = new MethodStatement(testCase, new GenericMethod(xStreamType.getMethod("fromXML", stringType), typeClass), xStreamRef, Arrays.asList(stringRepRef));
        this.oidToVarRefMap.put(oid, testCase.addStatement(m));
    } catch (final Exception e) {
        throw new RuntimeException(e);
    }
}

Example 4 with MethodStatement

use of org.evosuite.testcase.MethodStatement in project evosuite by EvoSuite.

the class TestCaseCodeGenerator method createMethodCallStmt.

private void createMethodCallStmt(final int logRecNo, final TestCase testCase) {
    // assumption: all necessary statements are created and there is one variable for reach referenced object
    final int oid = this.log.objectIds.get(logRecNo);
    final Object[] methodArgs = this.log.params.get(logRecNo);
    final String methodName = this.log.methodNames.get(logRecNo);
    final String methodDesc = this.log.descList.get(logRecNo);
    final org.objectweb.asm.Type[] methodParamTypes = org.objectweb.asm.Type.getArgumentTypes(methodDesc);
    final Class<?>[] methodParamTypeClasses = new Class[methodParamTypes.length];
    for (int i = 0; i < methodParamTypes.length; i++) {
        methodParamTypeClasses[i] = getClassFromType(methodParamTypes[i]);
    }
    final String typeName = this.log.oidClassNames.get(this.log.oidRecMapping.get(oid));
    Class<?> type;
    try {
        // Class.forName(typeName, true, StaticTestCluster.classLoader);
        type = getClassForName(typeName);
        final ArrayList<VariableReference> args = new ArrayList<VariableReference>();
        // is either an oid or null
        Integer argOID;
        for (int i = 0; i < methodArgs.length; i++) {
            argOID = (Integer) methodArgs[i];
            if (argOID == null) {
                args.add(testCase.addStatement(new NullStatement(testCase, methodParamTypeClasses[i])));
            } else {
                args.add(this.oidToVarRefMap.get(argOID));
            }
        }
        if (CaptureLog.OBSERVED_INIT.equals(methodName)) {
            // Person var0 = new Person();
            final ConstructorStatement constStmt = new ConstructorStatement(testCase, new GenericConstructor(type.getDeclaredConstructor(methodParamTypeClasses), type), args);
            this.oidToVarRefMap.put(oid, testCase.addStatement(constStmt));
        } else // ------------------ handling for ordinary method calls e.g. var1 = var0.doSth();
        {
            final Object returnValue = this.log.returnValues.get(logRecNo);
            if (CaptureLog.RETURN_TYPE_VOID.equals(returnValue)) {
                final MethodStatement m = new MethodStatement(testCase, new GenericMethod(this.getDeclaredMethod(type, methodName, methodParamTypeClasses), type.getMethod(methodName, methodParamTypeClasses).getReturnType()), this.oidToVarRefMap.get(oid), args);
                testCase.addStatement(m);
            } else {
                final org.objectweb.asm.Type returnType = org.objectweb.asm.Type.getReturnType(methodDesc);
                // Person var0 = var.getPerson();
                final MethodStatement m = new MethodStatement(testCase, new GenericMethod(this.getDeclaredMethod(type, methodName, methodParamTypeClasses), getClassFromType(returnType)), this.oidToVarRefMap.get(oid), args);
                final Integer returnValueOID = (Integer) returnValue;
                this.oidToVarRefMap.put(returnValueOID, testCase.addStatement(m));
            }
        }
    } catch (final Exception e) {
        throw new RuntimeException(e);
    }
}