Example #1
0
  public BodyDeclaration getTreeNode() {
    //        System.out.println("Building Method " + node.getName());

    String finalName = name + type.name() + Config.get().getTestMethodSuffix();
    MethodDeclaration result = new MethodDeclaration(ModifierSet.PUBLIC, new VoidType(), finalName);

    result.setComment(
        new BlockComment(
            "\n\t\tGenerated Unity test\n\t\t" + name + " - " + type.name() + " test." + "\n\t"));

    AnnotationExpr anno = new MarkerAnnotationExpr(new NameExpr("Test"));
    List<AnnotationExpr> annoList = new ArrayList<>();
    annoList.add(anno);
    result.setAnnotations(annoList);

    BlockStmt body = new BlockStmt();
    List<Statement> statements = new ArrayList<>();
    statements.add(instance.getStatement());

    body.setStmts(statements);
    result.setBody(body);

    // Set any mocks
    // Set instance
    // Set call parameters
    // Set call result
    // Set assertions
    return result;
  }
Example #2
0
 void changeTypeContext(ResolutionContext old, ResolutionContext new_, MethodDeclaration m) {
   m.setType(changeTypeContext(old, new_, m.getType()));
   m.setBody(
       new BlockStmt(
           Collections.singletonList(
               new ThrowStmt(
                   new ObjectCreationExpr(
                       null,
                       new ClassOrInterfaceType("UnsupportedOperationException"),
                       Collections.emptyList())))));
   NodeUtil.forChildren(
       m,
       node -> {
         Expression scope = node.getScope();
         // TODO: Currently guesses that it's a type name if first character is uppercase.
         // Should check for fields/variables which match instead
         if (scope instanceof NameExpr
             && Character.isUpperCase(((NameExpr) scope).getName().charAt(0))) {
           String name = ((NameExpr) scope).getName();
           node.setScope(ASTHelper.createNameExpr(new_.typeToString(old.resolve(name))));
         }
       },
       MethodCallExpr.class);
   NodeUtil.forChildren(
       m,
       node -> node.setType(changeTypeContext(old, new_, node.getType())),
       VariableDeclarationExpr.class);
   NodeUtil.forChildren(
       m, node -> node.setType(changeTypeContext(old, new_, node.getType())), TypeExpr.class);
   NodeUtil.forChildren(
       m,
       node -> node.setType(changeTypeContext(old, new_, node.getType())),
       com.github.javaparser.ast.body.Parameter.class);
 }
 @Override
 public void visit(MethodDeclaration methodDeclaration, Object arg) {
   if (methodDeclaration.getBody() != null) {
     for (Statement statement : methodDeclaration.getBody().getStmts()) {
       // check for starting a block statement
       if (statement instanceof SwitchStmt) {
         SwitchStmt switchStmt = (SwitchStmt) statement;
         for (SwitchEntryStmt switchEntryStmt : switchStmt.getEntries()) {
           reportExcessiveIndentation(switchEntryStmt.getStmts());
         }
       } else if (statement instanceof IfStmt) {
         Statement currentIf = statement;
         do {
           reportExcessiveIndentation(((IfStmt) currentIf).getThenStmt());
           currentIf = ((IfStmt) currentIf).getElseStmt();
         } while (currentIf instanceof IfStmt);
       } else if (statement instanceof WhileStmt) {
         reportExcessiveIndentation(((WhileStmt) statement).getBody());
       } else if (statement instanceof ForeachStmt) {
         reportExcessiveIndentation(((ForeachStmt) statement).getBody());
       } else if (statement instanceof ForStmt) {
         reportExcessiveIndentation(((ForStmt) statement).getBody());
       } else if (statement instanceof DoStmt) {
         reportExcessiveIndentation(((DoStmt) statement).getBody());
       }
     }
   }
   super.visit(methodDeclaration, arg);
 }
Example #4
0
 @Override
 public void setTypeVariables(List<TypeVariable> typeVariables) {
   declaration.setTypeParameters(
       typeVariables
           .stream()
           .map(getContext()::unresolveTypeVariable)
           .collect(Collectors.toList()));
 }
 // This generates all the test methods of the class, given a starting node
 private static List<BodyDeclaration> generateTestMethods(RoundTripPathTreeNode node) {
   final List<BlockStmt> bodies = generateTestBodies(node);
   final List<BodyDeclaration> methods = new ArrayList<BodyDeclaration>();
   int i = 0;
   for (BlockStmt body : bodies) {
     final MethodDeclaration method =
         new MethodDeclaration(
             ModifierSet.PUBLIC,
             new VoidType(),
             "conformanceTest" + i++,
             Collections.<Parameter>emptyList());
     method.getAnnotations().add(new MarkerAnnotationExpr(new NameExpr("Test")));
     method.setBody(body);
     methods.add(method);
   }
   return methods;
 }
Example #6
0
 @Override
 public List<TypeVariable> getTypeVariables() {
   return declaration
       .getTypeParameters()
       .stream()
       .map(getContext()::resolveTypeVariable)
       .collect(Collectors.toList());
 }
Example #7
0
  @Override
  public void add(MethodInfo method) {
    MethodDeclaration methodDeclaration;

    if (method instanceof MethodDeclarationWrapper) {
      val wrapper = (MethodDeclarationWrapper) method;
      methodDeclaration = (MethodDeclaration) wrapper.declaration.clone();
      methodDeclaration.setAnnotations(Collections.emptyList());
      wrapper
          .getClassInfo()
          .changeTypeContext(wrapper.getContext(), getContext(), methodDeclaration);
    } else {
      methodDeclaration = new MethodDeclaration();
      new MethodDeclarationWrapper(methodDeclaration).setAll(method);
    }

    addMember(methodDeclaration);
  }
Example #8
0
 @Override
 public List<Parameter> getParameters() {
   return declaration
       .getParameters()
       .stream()
       .map(
           (parameter) ->
               new Parameter(
                   getContext().resolve(parameter.getType()), parameter.getId().getName()))
       .collect(Collectors.toList());
 }
  private JavaMethod createMethod(MethodDeclaration method) {
    String className = classStack.peek().getName();
    String name = method.getName();
    boolean isStatic = ModifierSet.hasModifier(method.getModifiers(), ModifierSet.STATIC);
    String returnType = method.getType().toString();
    ArrayList<Argument> arguments = new ArrayList<Argument>();

    if (method.getParameters() != null) {
      for (Parameter parameter : method.getParameters()) {
        arguments.add(new Argument(getArgumentType(parameter), parameter.getId().getName()));
      }
    }

    return new JavaMethod(
        className,
        name,
        isStatic,
        returnType,
        null,
        arguments,
        method.getBeginLine(),
        method.getEndLine());
  }
Example #10
0
  @Override
  public Boolean visit(final MethodDeclaration n1, final Node arg) {
    final MethodDeclaration n2 = (MethodDeclaration) arg;

    // javadoc are checked at CompilationUnit

    if (n1.getModifiers() != n2.getModifiers()) {
      return Boolean.FALSE;
    }

    if (n1.getArrayCount() != n2.getArrayCount()) {
      return Boolean.FALSE;
    }

    if (!objEquals(n1.getName(), n2.getName())) {
      return Boolean.FALSE;
    }

    if (!nodeEquals(n1.getType(), n2.getType())) {
      return Boolean.FALSE;
    }

    if (!nodesEquals(n1.getAnnotations(), n2.getAnnotations())) {
      return Boolean.FALSE;
    }

    if (!nodeEquals(n1.getBody(), n2.getBody())) {
      return Boolean.FALSE;
    }

    if (!nodesEquals(n1.getParameters(), n2.getParameters())) {
      return Boolean.FALSE;
    }

    if (!nodesEquals(n1.getThrows(), n2.getThrows())) {
      return Boolean.FALSE;
    }

    if (!nodesEquals(n1.getTypeParameters(), n2.getTypeParameters())) {
      return Boolean.FALSE;
    }
    if (n1.isDefault() != n2.isDefault()) {
      return Boolean.FALSE;
    }
    return Boolean.TRUE;
  }
Example #11
0
 @Override
 public AccessFlags getAccessFlags() {
   return new AccessFlags(declaration.getModifiers());
 }
Example #12
0
 @Override
 public void setReturnType(Type type) {
   declaration.setType(setType(type, declaration.getType()));
 }
Example #13
0
 @Override
 public Type getReturnType() {
   return getContext().resolve(declaration.getType());
 }
Example #14
0
 @Override
 public String getName() {
   return declaration.getName();
 }
Example #15
0
 @Override
 public void setName(String name) {
   declaration.setName(name);
 }
Example #16
0
 @Override
 public List<Annotation> getAnnotations() {
   return SourceInfo.this.getAnnotationsInternal(declaration.getAnnotations());
 }
Example #17
0
 @Override
 public void setAccessFlags(AccessFlags accessFlags) {
   declaration.setModifiers(accessFlags.access);
 }
 @Override
 public void visit(final MethodDeclaration n, final A arg) {
   visitComment(n.getComment(), arg);
   visitAnnotations(n, arg);
   if (n.getTypeParameters() != null) {
     for (final TypeParameter t : n.getTypeParameters()) {
       t.accept(this, arg);
     }
   }
   n.getElementType().accept(this, arg);
   n.getNameExpr().accept(this, arg);
   if (n.getParameters() != null) {
     for (final Parameter p : n.getParameters()) {
       p.accept(this, arg);
     }
   }
   if (n.getThrows() != null) {
     for (final ReferenceType name : n.getThrows()) {
       name.accept(this, arg);
     }
   }
   if (n.getBody() != null) {
     n.getBody().accept(this, arg);
   }
 }