public <T> void visitCtAssert(final spoon.reflect.code.CtAssert<T> asserted) { spoon.reflect.code.CtAssert<T> aCtAssert = asserted.getFactory().Core().createAssert(); this.builder.copy(asserted, aCtAssert); aCtAssert.setAnnotations(this.cloneHelper.clone(asserted.getAnnotations())); aCtAssert.setAssertExpression(this.cloneHelper.clone(asserted.getAssertExpression())); aCtAssert.setExpression(this.cloneHelper.clone(asserted.getExpression())); aCtAssert.setComments(this.cloneHelper.clone(asserted.getComments())); this.cloneHelper.tailor(asserted, aCtAssert); this.other = aCtAssert; }
@Override public <T> void visitCtAssert(CtAssert<T> asserted) { if (child instanceof CtExpression) { if (asserted.getAssertExpression() == null) { asserted.setAssertExpression((CtExpression<Boolean>) child); return; } else { asserted.setExpression((CtExpression<T>) child); return; } } super.visitCtAssert(asserted); }
public <T> void visitCtAssert(final spoon.reflect.code.CtAssert<T> asserted) { spoon.reflect.code.CtAssert other = ((spoon.reflect.code.CtAssert) (this.stack.peek())); enter(asserted); biScan(spoon.reflect.path.CtRole.ANNOTATION, asserted.getAnnotations(), other.getAnnotations()); biScan(spoon.reflect.path.CtRole.CONDITION, asserted.getAssertExpression(), other.getAssertExpression()); biScan(spoon.reflect.path.CtRole.EXPRESSION, asserted.getExpression(), other.getExpression()); biScan(spoon.reflect.path.CtRole.COMMENT, asserted.getComments(), other.getComments()); exit(asserted); }
@Override public <T> void visitCtAssert(CtAssert<T> asserted) { if (child instanceof CtExpression) { if (!this.jdtTreeBuilder.context.arguments.isEmpty() && this.jdtTreeBuilder.context.arguments.peek() == asserted) { asserted.setExpression((CtExpression<T>) child); return; } else { asserted.setAssertExpression((CtExpression<Boolean>) child); return; } } super.visitCtAssert(asserted); }
@SuppressWarnings({ "unchecked", "rawtypes" }) @Override public <T> void visitCtAssert(CtAssert<T> asserted) { super.visitCtAssert(asserted); CtExpression exper=asserted.getExpression(); if (candidates.containsKey(exper)) { asserted.setExpression(candidates.get(exper)); saveSketchAndSynthesize(); asserted.setExpression(exper); resoreDiskFile(); } CtExpression assertexper=asserted.getAssertExpression(); if (candidates.containsKey(assertexper)) { asserted.setAssertExpression(candidates.get(assertexper)); saveSketchAndSynthesize(); asserted.setAssertExpression(assertexper); resoreDiskFile(); } }
@Override public <T> void visitCtAssert(CtAssert<T> asserted) { enterCtStatement(asserted); printer.writeKeyword("assert").writeSpace(); scan(asserted.getAssertExpression()); if (asserted.getExpression() != null) { printer.writeSpace().writeSeparator(":").writeSpace(); scan(asserted.getExpression()); } exitCtStatement(asserted); }
public <T> void visitCtAssert(CtAssert<T> asserted) { enter(asserted); scan(asserted.getAnnotations()); scan(asserted.getAssertExpression()); scan(asserted.getExpression()); exit(asserted); }
@java.lang.Override public void set(spoon.reflect.code.CtExpression replace) { this.element.setAssertExpression(replace); } }
@java.lang.Override public void set(spoon.reflect.code.CtExpression replace) { this.element.setExpression(replace); } }
@SuppressWarnings("unchecked") @Override public <T, U> U getValue(T element) { return ((U) ((Object) (castTarget(element).getAssertExpression()))); }
@SuppressWarnings("unchecked") @Override public <T, U> U getValue(T element) { return ((U) ((Object) (castTarget(element).getExpression()))); }
@Override public <T> CtAssert<T> createAssert() { CtAssert<T> e = new CtAssertImpl<>(); e.setFactory(getMainFactory()); return e; }
/** * 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; }
public <T> void visitCtAssert(final CtAssert<T> asserted) { enter(asserted); scan(CtRole.ANNOTATION, asserted.getAnnotations()); scan(CtRole.CONDITION, asserted.getAssertExpression()); scan(CtRole.EXPRESSION, asserted.getExpression()); scan(CtRole.COMMENT, asserted.getComments()); exit(asserted); }
public <T> void visitCtAssert(CtAssert<T> asserted) { signature.append("assert "); scan(asserted.getAssertExpression()); signature.append(":"); scan(asserted.getExpression()); }
@Override public <T, U> void setValue(T element, U value) { castTarget(element).setAssertExpression(castValue(value)); } }
@Override public <T, U> void setValue(T element, U value) { castTarget(element).setExpression(castValue(value)); } }
public <T> CtAssert<T> createAssert() { CtAssert<T> e = new CtAssertImpl<T>(); e.setFactory(getMainFactory()); return e; }
private <T> void addGuardingPrologue(CtMethod<T> proxy) { if (noArgInitStageMethod != null) { CtIf ctIf = createNotInitIf(); ctIf.setThenStatement(f().Code().createInvocation(thisAccess(), noArgInitStageMethod.getReference())); proxy.getBody().addStatement(ctIf); } else { CtAssert<String> ctAssert = f().Core().createAssert(); ctAssert.setAssertExpression(createStageInitInvocation()); ctAssert.setExpression(f().Code().createLiteral(name + " should be init")); proxy.getBody().addStatement(ctAssert); } }
@java.lang.Override public <T> void visitCtAssert(final spoon.reflect.code.CtAssert<T> asserted) { replaceInListIfExist(asserted.getAnnotations(), new spoon.support.visitor.replace.ReplacementVisitor.CtElementAnnotationsReplaceListener(asserted)); replaceElementIfExist(asserted.getAssertExpression(), new spoon.support.visitor.replace.ReplacementVisitor.CtAssertAssertExpressionReplaceListener(asserted)); replaceElementIfExist(asserted.getExpression(), new spoon.support.visitor.replace.ReplacementVisitor.CtAssertExpressionReplaceListener(asserted)); replaceInListIfExist(asserted.getComments(), new spoon.support.visitor.replace.ReplacementVisitor.CtElementCommentsReplaceListener(asserted)); }