public <T> void visitCtMethod(final spoon.reflect.declaration.CtMethod<T> m) { spoon.reflect.declaration.CtMethod<T> aCtMethod = m.getFactory().Core().createMethod(); this.builder.copy(m, aCtMethod); aCtMethod.setAnnotations(this.cloneHelper.clone(m.getAnnotations())); aCtMethod.setFormalCtTypeParameters(this.cloneHelper.clone(m.getFormalCtTypeParameters())); aCtMethod.setType(this.cloneHelper.clone(m.getType())); aCtMethod.setParameters(this.cloneHelper.clone(m.getParameters())); aCtMethod.setThrownTypes(this.cloneHelper.clone(m.getThrownTypes())); aCtMethod.setBody(this.cloneHelper.clone(m.getBody())); aCtMethod.setComments(this.cloneHelper.clone(m.getComments())); this.cloneHelper.tailor(m, aCtMethod); this.other = aCtMethod; }
public MethodTypingContext setMethod(CtMethod<?> method) { actualTypeArguments = getTypeReferences(method.getFormalCtTypeParameters()); if (classTypingContext != null) { CtType<?> declType = method.getDeclaringType(); if (declType == null) { throw new SpoonException("Cannot use method without declaring type as scope of method typing context"); Factory factory = method.getFactory(); adaptedMethod.setParent(classTypingContext.getAdaptationScope()); adaptedMethod.setModifiers(method.getModifiers()); adaptedMethod.setSimpleName(method.getSimpleName()); for (CtTypeParameter typeParam : method.getFormalCtTypeParameters()) { CtTypeParameter newTypeParam = typeParam.clone(); newTypeParam.setSuperclass(adaptTypeForNewMethod(typeParam.getSuperclass())); adaptedMethod.addFormalCtTypeParameter(newTypeParam); for (CtTypeReference<? extends Throwable> thrownType : method.getThrownTypes()) { adaptedMethod.addThrownType((CtTypeReference<Throwable>) adaptType(thrownType.clone())); adaptedMethod.setType((CtTypeReference) adaptType(method.getType())); List<CtParameter<?>> adaptedParams = new ArrayList<>(method.getParameters().size()); for (CtParameter<?> parameter : method.getParameters()) { adaptedParams.add(factory.Executable().createParameter(null, adaptType(parameter.getType()), parameter.getSimpleName())); adaptedMethod.setParameters(adaptedParams);
/** * Creates a new invocation filter. * * @param method * the executable to be tested for being invoked. */ public InvocationFilter(CtMethod<?> method) { this(method.getReference()); }
/** * @return a value type of this method */ public CtTypeReference<?> getValueType() { if (method.getParameters().isEmpty()) { return method.getType(); } return method.getParameters().get(method.getParameters().size() - 1).getType(); }
public <T> void visitCtMethod(final spoon.reflect.declaration.CtMethod<T> m) { spoon.reflect.declaration.CtMethod other = ((spoon.reflect.declaration.CtMethod) (this.stack.peek())); enter(m); biScan(spoon.reflect.path.CtRole.ANNOTATION, m.getAnnotations(), other.getAnnotations()); biScan(spoon.reflect.path.CtRole.TYPE_PARAMETER, m.getFormalCtTypeParameters(), other.getFormalCtTypeParameters()); biScan(spoon.reflect.path.CtRole.TYPE, m.getType(), other.getType()); biScan(spoon.reflect.path.CtRole.PARAMETER, m.getParameters(), other.getParameters()); biScan(spoon.reflect.path.CtRole.THROWN, m.getThrownTypes(), other.getThrownTypes()); biScan(spoon.reflect.path.CtRole.BODY, m.getBody(), other.getBody()); biScan(spoon.reflect.path.CtRole.COMMENT, m.getComments(), other.getComments()); exit(m); }
/** * Creates a constructor into a target class by copying it from a source * method. * * @param target * the target class * @param source * the method to be copied * @return the new constructor */ @SuppressWarnings("unchecked") public <T> CtConstructor<T> create(CtClass<T> target, CtMethod<?> source) { CtMethod<T> method = (CtMethod<T>) source.clone(); CtConstructor<T> newConstructor = factory.Core().createConstructor(); newConstructor.setAnnotations(method.getAnnotations()); newConstructor.setBody(method.getBody()); newConstructor.setDocComment(method.getDocComment()); newConstructor.setFormalCtTypeParameters(method.getFormalCtTypeParameters()); newConstructor.setModifiers(method.getModifiers()); newConstructor.setParameters(method.getParameters()); target.addConstructor(newConstructor); return newConstructor; }
public <T> void visitCtMethod(CtMethod<T> m) { enter(m); scan(m.getAnnotations()); scan(m.getType()); scan(m.getParameters()); scanReferences(m.getThrownTypes()); scanReferences(m.getFormalTypeParameters()); scan(m.getBody()); exit(m); }
@Override public CtMethod<?> minimize(CtMethod<?> amplifiedTestToBeMinimized) { final CtMethod<?> generalMinimize = super.minimize(amplifiedTestToBeMinimized); final CtMethod<?> changeMinimize = generalMinimize.clone(); final long time = System.currentTimeMillis(); final Failure failureToKeep = this.failurePerAmplifiedTest.get(amplifiedTestToBeMinimized); final List<CtInvocation> assertions = changeMinimize.filterChildren(TestFramework.ASSERTIONS_FILTER).list(); LOGGER.info("Minimizing {} assertions.", assertions.size()); assertions.forEach(invocation -> { DSpotUtils.printProgress(assertions.indexOf(invocation), assertions.size()); tryToRemoveAssertion(changeMinimize, invocation, failureToKeep ); } ); LOGGER.info("Reduce {}, {} statements to {} statements in {} ms.", amplifiedTestToBeMinimized.getSimpleName(), generalMinimize.getBody().getStatements().size(), changeMinimize.getBody().getStatements().size(), System.currentTimeMillis() - time ); // now that we reduce the amplified test, we must update the stack trace updateStackTrace(amplifiedTestToBeMinimized, changeMinimize); return changeMinimize; }
@Override public CtMethod<?> minimize(CtMethod<?> amplifiedTestToBeMinimized) { final CtMethod<?> clone = amplifiedTestToBeMinimized.clone(); final long time = System.currentTimeMillis(); LOGGER.info("Inlining one time used variables..."); inlineLocalVariable(clone); LOGGER.info("Remove redundant assertions..."); removeRedundantAssertions(clone); LOGGER.info("Reduce {}, {} statements to {} statements in {} ms.", amplifiedTestToBeMinimized.getSimpleName(), amplifiedTestToBeMinimized.getBody().getStatements().size(), clone.getBody().getStatements().size(), System.currentTimeMillis() - time ); return clone; }
@Override @SuppressWarnings("unchecked") public <R> CtMethod<R> getMethod(CtTypeReference<R> returnType, String name, CtTypeReference<?>... parameterTypes) { for (CtTypeMember typeMember : typeMembers) { if (!(typeMember instanceof CtMethod)) { continue; } CtMethod<R> m = (CtMethod<R>) typeMember; if (m.getSimpleName().equals(name)) { if (!m.getType().equals(returnType)) { continue; } boolean cont = m.getParameters().size() == parameterTypes.length; for (int i = 0; cont && (i < m.getParameters().size()) && (i < parameterTypes.length); i++) { if (!m.getParameters().get(i).getType().getQualifiedName().equals(parameterTypes[i].getQualifiedName())) { cont = false; } } if (cont) { return m; } } } return null; }
@Override public CtMethod<?> generateExpectedExceptionsBlock(CtMethod<?> test, Failure failure, int numberOfFail) { final Factory factory = InputConfiguration.get().getFactory(); final String[] split = failure.fullQualifiedNameOfException.split("\\."); final String simpleNameOfException = split[split.length - 1]; CtTry tryBlock = factory.Core().createTry(); tryBlock.setBody(test.getBody()); String snippet = this.qualifiedNameOfAssertClass + ".fail(\"" + test.getSimpleName() + " should have thrown " + simpleNameOfException + "\")"; tryBlock.getBody().addStatement(factory.Code().createCodeSnippetStatement(snippet)); DSpotUtils.addComment(tryBlock, "AssertGenerator generate try/catch block with fail statement", CtComment.CommentType.INLINE); CtCatch ctCatch = factory.Core().createCatch(); CtTypeReference exceptionType = factory.Type().createReference(failure.fullQualifiedNameOfException); ctCatch.setParameter(factory.Code().createCatchVariable(exceptionType, this.getCorrectExpectedNameOfException(test))); ctCatch.setBody(factory.Core().createBlock()); List<CtCatch> catchers = new ArrayList<>(1); catchers.add(ctCatch); addAssertionOnException(test, ctCatch, failure); tryBlock.setCatchers(catchers); CtBlock body = factory.Core().createBlock(); body.addStatement(tryBlock); test.setBody(body); test.setSimpleName(test.getSimpleName() + "_failAssert" + (numberOfFail)); return test; }
@Override public boolean matches(CtMethod<?> element) { return element.getModifiers().contains(ModifierKind.STATIC) && Arrays.stream(NAME_OF_FACTORY_METHOD) .anyMatch(element.getSimpleName().toLowerCase()::contains) && element.getType().equals(type) && element.getParameters().stream() .map(CtParameter::getType) .allMatch(ValueCreatorHelper::canGenerateAValueForType); } }
elementPrinterHelper.writeModifiers(m); elementPrinterHelper.writeFormalTypeParameters(m); if (!m.getFormalCtTypeParameters().isEmpty()) { printer.writeSpace(); scan(m.getType()); printer.writeIdentifier(m.getSimpleName()); elementPrinterHelper.writeExecutableParameters(m); elementPrinterHelper.writeThrowsClause(m); if (m.getBody() != null) { printer.writeSpace(); scan(m.getBody()); if (m.getBody().getPosition().isValidPosition()) { if (m.getBody().getPosition().getCompilationUnit() == sourceCompilationUnit) { if (m.getBody().getStatements().isEmpty() || !(m.getBody().getStatements().get(m.getBody().getStatements().size() - 1) instanceof CtReturn)) { getPrinterHelper().putLineNumberMapping(m.getBody().getPosition().getEndLine());
/** * Clones a method. * * @param method Method to be cloned * @param suffix Suffix for the cloned method's name * @return The cloned method */ public static CtMethod cloneMethod(CtMethod<?> method, String suffix) { CtMethod cloned_method = method.clone(); //rename the clone cloned_method.setSimpleName(method.getSimpleName() + (suffix.isEmpty() ? "" : suffix + cloneNumber)); cloneNumber++; CtAnnotation toRemove = cloned_method.getAnnotations().stream() .filter(annotation -> annotation.toString().contains("Override")) .findFirst().orElse(null); if (toRemove != null) { cloned_method.removeAnnotation(toRemove); } return cloned_method; }
@Override public Optional<CtMethod<Void>> getCloseMethod() { if (closeMethod != null && !closeMethod.hasModifier(ABSTRACT)) { initCloseMethodStatements(); return of(closeMethod); } assert initField != null; closeMethodGenerated = true; if (closeMethod == null) { closeMethod = createSimpleMethod(f().Type().VOID_PRIMITIVE, closeMethodName()); cxt.bindClose(closeMethod, this); } else { closeMethod.setBody(f().Core().createBlock()); closeMethod.removeModifier(ABSTRACT); } closeMethod.getBody().addStatement(net.openhft.sg.SpoonUtils.reassignDefault(initField)); initCloseMethodStatements(); return of(closeMethod); }
IntStream.range(0, 2) .forEach(index -> { final CtMethod<?> clone = ctMethod.clone(); clone.setSimpleName(clone.getSimpleName() + "_" + index); testClass.addMethod(clone); addedMethod.add(clone); testDownAfterClass.getBody().removeStatement((CtStatement) addedElement);
/** See doc in {@link CtMethod#copyMethod()} */ public static CtMethod<?> copyMethod(final CtMethod<?> method) { CtMethod<?> clone = method.clone(); StringBuilder tentativeTypeName = new StringBuilder(method.getSimpleName() + "Copy"); CtType parent = method.getParent(CtType.class); while (!parent.getMethodsByName(tentativeTypeName.toString()).isEmpty()) { tentativeTypeName.append("X"); } final String cloneMethodName = tentativeTypeName.toString(); clone.setSimpleName(cloneMethodName); parent.addMethod(clone); new CtScanner() { @Override public <T> void visitCtExecutableReference(CtExecutableReference<T> reference) { CtExecutable<T> declaration = reference.getDeclaration(); if (declaration == null) { return; } if (declaration == method) { reference.setSimpleName(cloneMethodName); } if (reference.getDeclaration() != clone) { throw new SpoonException("post condition broken " + reference); } super.visitCtExecutableReference(reference); } }.scan(clone); return clone; }
private CtMethod valuesMethod() { if (valuesMethod == null) { valuesMethod = getFactory().Core().createMethod(); valuesMethod.setParent(this); valuesMethod.addModifier(ModifierKind.PUBLIC); valuesMethod.addModifier(ModifierKind.STATIC); valuesMethod.setSimpleName("values"); valuesMethod.setImplicit(true); valuesMethod.setType(factory.Type().createArrayReference(getReference())); } return valuesMethod; }
@Override public void addMethod(CtMethod ctMethod) { final CtAnnotationMethod<Object> field = factory.Core().createAnnotationMethod(); field.setSimpleName(ctMethod.getSimpleName()); field.setModifiers(ctMethod.getModifiers()); field.setType(ctMethod.getType()); field.setShadow(true); ctAnnotationType.addMethod(field); } });
/** * @return name of this {@link MMMethod}. It is equal to simple name of related {@link CtMethod} */ public String getName() { return method.getSimpleName(); }