Ejemplo n.º 1
0
  private static <T> void processConstructor(CtConstructor<T> c, CtClass<T> toMerge) {
    CtStatement firstStmt = c.getBody().getStatements().get(0);
    if (firstStmt instanceof CtInvocation) {
      CtInvocation<?> superConstructorCall = (CtInvocation) firstStmt;
      if (!(superConstructorCall.getExecutable().getDeclaration() instanceof CtConstructor)) return;
      CtConstructor superConstructor =
          (CtConstructor) superConstructorCall.getExecutable().getDeclaration();
      if (superConstructor.getDeclaringType() == toMerge) {
        CtBlock superConstructorBody = c.getFactory().Core().clone(superConstructor.getBody());
        superConstructorBody.accept(
            new CtScanner() {
              @Override
              public <T> void visitCtParameterReference(CtParameterReference<T> ref) {
                int parameterOrder = superConstructor.getParameters().indexOf(ref.getDeclaration());
                ref.setDeclaringExecutable(c.getReference());
                CtExpression<?> arg = superConstructorCall.getArguments().get(parameterOrder);
                if (!(arg instanceof CtVariableAccess))
                  throw sgce("super() should be directly called in " + c);
                CtVariable param = ((CtVariableAccess) arg).getVariable().getDeclaration();
                if (!(param instanceof CtParameter))
                  throw sgce("super() should be directly called in " + c);
                ref.setSimpleName(param.getSimpleName());

                super.visitCtParameterReference(ref);
              }
            });
        c.getBody().removeStatement(firstStmt);
        List<CtStatement> superConstructorBodyStatements = superConstructorBody.getStatements();
        for (int i = superConstructorBodyStatements.size() - 1; i >= 0; i--) {
          c.getBody().insertBegin(superConstructorBodyStatements.get(i));
        }
      }
    }
  }
Ejemplo n.º 2
0
  /**
   * Create the content of the condition
   *
   * @param ctInvocation
   * @return
   */
  private CtBlock<Object> createThen(CtInvocation<?> ctInvocation) {
    CtBlock<Object> thenStatement = ctInvocation.getFactory().Core().createBlock();
    thenStatement.addStatement(
        (getFactory().Code().createCodeSnippetStatement("System.out.println(\"Else...\")")));
    thenStatement.addStatement(
        (getFactory()
            .Code()
            .createCodeSnippetStatement(
                "System.out.println(" + Debug.class.getCanonicalName() + ".getSolvedPC())")));

    CtAssert<Object> ctAssert = ctInvocation.getFactory().Core().createAssert();

    CtCodeSnippetExpression<Boolean> assertExpression =
        getFactory().Core().createCodeSnippetExpression();
    assertExpression.setValue("false");

    ctAssert.setAssertExpression(assertExpression);
    ctAssert.setExpression(
        getFactory()
            .Code()
            .createCodeSnippetExpression(
                String.format("\"%s\"", ctInvocation.toString().replaceAll("\"", "'"))));

    thenStatement.addStatement(ctAssert);

    return thenStatement;
  }
Ejemplo n.º 3
0
  private void createExecutionMethod(CtInvocation<?> ctInvocation) {
    CtClass<?> parent = ctInvocation.getParent(CtClass.class);
    if (!parent.isTopLevel()) {
      return;
    }
    if (parent.getModifiers().contains(ModifierKind.ABSTRACT)) {
      return;
    }
    CtTypeReference<String[]> typedReference = getFactory().Class().createReference(String[].class);
    if (parent.getMethod("runJPFTest", typedReference) != null) {
      return;
    }
    CtTypeReference<Object> returntypedReference = getFactory().Class().createReference("void");

    Set<ModifierKind> modifiers = new LinkedHashSet<ModifierKind>(2);
    modifiers.add(ModifierKind.PUBLIC);
    modifiers.add(ModifierKind.STATIC);

    String invocation = parent.getQualifiedName() + "(";
    if (parent.getConstructor() == null) {
      // CtTypeReference<?> superClass = parent.getSuperclass();
      if (parent.getConstructor(ctInvocation.getFactory().Class().STRING) != null) {
        invocation += "\"" + parent.getSimpleName() + "\"";
      } else {
        return;
      }
    }
    invocation += ")";

    CtBlock<?> body = getFactory().Core().createBlock();
    String bodyString = "for (String method : methods) {\n";
    bodyString += "\t\tSystem.out.println(method);\n\t\t";
    bodyString += parent.getQualifiedName() + " instance = new " + invocation + ";\n\t\t";
    if (parent.getMethod("setUp") != null) {
      bodyString += "instance.setUp();";
    }
    bodyString +=
        parent.getQualifiedName() + ".class.getMethod(method, null).invoke(instance);\n\t\t";
    bodyString += "}\n";
    body.addStatement(getFactory().Code().createCodeSnippetStatement(bodyString));
    HashSet<CtTypeReference<? extends Throwable>> exceptions =
        new HashSet<CtTypeReference<? extends Throwable>>();
    exceptions.add(getFactory().Class().createReference(Exception.class));
    CtMethod<?> method =
        getFactory()
            .Method()
            .create(
                parent,
                modifiers,
                returntypedReference,
                "runJPFTest",
                new ArrayList<CtParameter<?>>(),
                exceptions,
                body);
    getFactory().Method().createParameter(method, typedReference, "methods");
  }
 @Override
 public <R> void visitCtBlock(CtBlock<R> block) {
   int i = 0;
   while (i < block.getStatements().size()) {
     int size = block.getStatements().size();
     CtStatement s = block.getStatement(i);
     s.accept(this);
     if (block.getStatements().size() >= size) i++;
   }
 }
 /**
  * Replaces the element by an statement list containing all unary operators in the element
  *
  * @param element
  */
 private void replaceByUnaryBlock(CtElement element) {
   CtBlock<CtUnaryOperator> opBlock = new CtBlockImpl<CtUnaryOperator>();
   for (CtUnaryOperator s :
       element.getElements(new TypeFilter<CtUnaryOperator>(CtUnaryOperator.class)))
     if (s.getKind().compareTo(UnaryOperatorKind.PREINC) >= 0) {
       s.setParent(null);
       opBlock.addStatement(s);
       s.setParent(opBlock);
     }
   element.replace(opBlock);
 }
  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;
  }
 /**
  * Pretty print for the resulting degraded block
  *
  * @param clonedBody
  * @return
  */
 public String prettyPrintBody(CtStatement clonedBody) {
   String result = "";
   if (clonedBody instanceof CtBlock) {
     CtBlock block = (CtBlock) clonedBody;
     try {
       for (int i = 0; i < block.getStatements().size(); i++) {
         if (block.getStatement(i) instanceof CtBlock)
           result += prettyPrintBody(block.getStatement(i));
         else if (block.getStatement(i) != null)
           result += block.getStatement(i).toString() + ";\n";
       }
     } catch (NullPointerException ex) {
       log.error("Unable to print the degraded loop!");
     }
   } else result = clonedBody.toString();
   return result;
 }