protected List<List<Statement>> buildContext(
      InputContext inputContext, List<Statement> stmts, int targetIndex) {
    VarCartesianProduct varCartesianProduct = new VarCartesianProduct();
    Statement statement = stmts.get(targetIndex);

    for (CtVariableReference var : statement.getInputContext().getVar()) {

      varCartesianProduct.addReplaceVar(var, valueCreator.createNull(var.getType()));

      List<CtVariableReference> candidates = inputContext.allCandidate(var.getType(), true, false);
      if (!candidates.isEmpty()) {
        varCartesianProduct.addReplaceVar(
            var, candidates.get(AmplificationHelper.getRandom().nextInt(candidates.size())));
      }

      Statement cfLocalVar = getLocalVar(var.getType(), inputContext);
      if (cfLocalVar != null) {
        varCartesianProduct.addReplaceVar(var, cfLocalVar);
      }

      CtLocalVariable localVariable =
          createLocalVarFromMethodLiterals(currentMethod, var.getType());
      if (localVariable != null) {
        varCartesianProduct.addReplaceVar(var, localVariable);
      }

      CtLocalVariable randomVar = valueCreator.createRandomLocalVar(var.getType());
      if (randomVar != null) {
        varCartesianProduct.addReplaceVar(var, randomVar);
      }
    }

    return varCartesianProduct.apply(stmts, targetIndex);
  }
Ejemplo n.º 2
0
  /**
   * replace assertTrue
   *
   * @param ctInvocation
   * @return
   */
  private CtStatement replaceAssertTrueFalse(boolean type, CtInvocation<?> ctInvocation) {
    List<?> arguments = ctInvocation.getArguments();
    CtIf newIf = ctInvocation.getFactory().Core().createIf();

    Object elem1 = arguments.get(0);
    if (arguments.size() > 1) {
      elem1 = arguments.get(1);
    }
    if (!type) {
      CtExpression<Boolean> condition =
          ctInvocation.getFactory().Code().createCodeSnippetExpression("!(" + elem1 + ")");
      newIf.setCondition(condition);
    } else {
      newIf.setCondition((CtExpression<Boolean>) elem1);
    }
    // newIf.setThenStatement(getFactory().Code().createCodeSnippetStatement(
    // Debug.class.getCanonicalName() + ".printPC(\"Path Condition: \")"));
    /*
     * CtBlock<Object> thenStatement = ctInvocation.getFactory().Core()
     * .createBlock(); // thenStatement.addStatement((getFactory().Code().
     * createCodeSnippetStatement("System.out.println(\"Then...\")")));
     * thenStatement.addStatement((getFactory().Code()
     * .createCodeSnippetStatement("System.out.println(" +
     * Debug.class.getCanonicalName() + ".getSolvedPC())")));
     * newIf.setThenStatement(thenStatement);
     */
    newIf.setThenStatement(createThen(ctInvocation));
    return newIf;
  }
  protected CtLocalVariable createLocalVarFromMethodLiterals(
      CtMethod method, CtTypeReference type) {
    List<CtLiteral> literals =
        getLiterals(method)
            .stream()
            .filter(lit -> lit.getType() != null)
            .filter(lit -> lit.getType().equals(type))
            .collect(Collectors.toList());

    if (literals.isEmpty()) {
      return null;
    }

    CtLiteral lit = literals.get(AmplificationHelper.getRandom().nextInt(literals.size()));
    return type.getFactory().Code().createLocalVariable(type, "vc_" + count++, lit);
  }
 @Override
 public List<CtMethod> apply(CtMethod method) {
   currentMethod = method;
   List<CtMethod> newMethods = new ArrayList<>();
   if (!coverageBycodeFragments.isEmpty()) {
     List<InputContext> inputContexts = getInputContexts(method);
     if (!inputContexts.isEmpty()) {
       int index = inputContexts.size() - 1;
       List<List<Statement>> statements = buildStatements(inputContexts.get(index));
       for (List<Statement> list : statements) {
         try {
           newMethods.add(apply(method, list, index));
         } catch (Exception e) {
           throw new RuntimeException(e);
         }
       }
     }
   }
   return AmplificationHelper.updateAmpTestToParent(newMethods, method);
 }
Ejemplo n.º 5
0
  /**
   * replace assertNotNull
   *
   * @param ctInvocation
   * @return
   */
  private CtStatement replaceAssertNotNull(CtInvocation<?> ctInvocation) {
    List<?> arguments = ctInvocation.getArguments();
    CtIf newIf = ctInvocation.getFactory().Core().createIf();

    Object elem1 = arguments.get(0);
    CtExpression<Boolean> condition =
        ctInvocation.getFactory().Code().createCodeSnippetExpression("(" + elem1 + ") != null");
    newIf.setCondition(condition);
    // newIf.setThenStatement(getFactory().Code().createCodeSnippetStatement(
    // Debug.class.getCanonicalName() + ".printPC(\"Path Condition: \")"));
    /*
     * CtBlock<Object> thenStatement = ctInvocation.getFactory().Core()
     * .createBlock(); thenStatement .addStatement((getFactory().Code()
     * .createCodeSnippetStatement("System.out.println(\"Then...\")")));
     * thenStatement.addStatement((getFactory().Code()
     * .createCodeSnippetStatement("System.out.println(" +
     * Debug.class.getCanonicalName() + ".getSolvedPC())")));
     * newIf.setThenStatement(thenStatement);
     */
    newIf.setThenStatement(createThen(ctInvocation));
    return newIf;
  }
  protected List<CtLocalVariable> getLocalVarInScope(CtStatement stmt) {
    List<CtLocalVariable> vars = new ArrayList<>();
    try {
      CtBlock parentBlock = stmt.getParent(CtBlock.class);
      if (parentBlock != null) {
        boolean beforeCurrentStmt = true;
        int i = 0;
        List<CtStatement> stmts = parentBlock.getStatements();

        while (beforeCurrentStmt && i < stmts.size()) {
          CtStatement currentStatement = stmts.get(i);
          i++;
          beforeCurrentStmt = beforeCurrentStmt && currentStatement != stmt;
          if (currentStatement instanceof CtLocalVariable) {
            vars.add((CtLocalVariable) currentStatement);
          }
        }
        vars.addAll(getLocalVarInScope(parentBlock));
      }
    } catch (Exception e) {
      throw new RuntimeException(e);
    }
    return vars;
  }