use of spoon.reflect.code.CtStatement in project spoon by INRIA.
the class TestLabels method testLabelsAreDetected.
@Test
public void testLabelsAreDetected() {
Launcher launcher = new Launcher();
launcher.addInputResource("./src/test/java/spoon/test/labels/testclasses/ManyLabels.java");
launcher.buildModel();
CtMethod mainMethod = launcher.getFactory().getModel().getElements(new NamedElementFilter<>(CtMethod.class, "main")).get(0);
CtBlock body = mainMethod.getBody();
assertEquals(2, body.getStatements().size());
CtBlock block = (CtBlock) body.getStatement(0);
CtSwitch ctSwitch = (CtSwitch) body.getStatement(1);
assertEquals("labelBlock", block.getLabel());
assertEquals("sw", ctSwitch.getLabel());
assertTrue(block.getStatement(1) instanceof CtIf);
CtIf firstIf = (CtIf) block.getStatement(1);
CtBlock then = firstIf.getThenStatement();
CtBreak firstBreak = (CtBreak) then.getStatement(1);
assertEquals("labelBlock", firstBreak.getTargetLabel());
assertSame(block, firstBreak.getLabelledStatement());
CtIf secondIf = (CtIf) block.getStatement(2);
assertEquals("labelIf", secondIf.getLabel());
CtBlock thenBlock = secondIf.getThenStatement();
CtIf innerIf = (CtIf) thenBlock.getStatement(0);
CtBlock innerThenBlock = innerIf.getThenStatement();
CtBreak breakInnerIf = (CtBreak) innerThenBlock.getStatement(0);
assertSame(secondIf, breakInnerIf.getLabelledStatement());
CtCase firstCase = (CtCase) ctSwitch.getCases().get(0);
List<CtStatement> statementList = firstCase.getStatements();
assertEquals(2, statementList.size());
CtDo ctDo = (CtDo) statementList.get(0);
assertEquals("label", ctDo.getLabel());
CtBreak finalBreak = (CtBreak) statementList.get(1);
assertNull(finalBreak.getTargetLabel());
assertNull(finalBreak.getLabelledStatement());
CtBlock doBlock = (CtBlock) ctDo.getBody();
CtWhile ctWhile = (CtWhile) doBlock.getStatement(1);
assertEquals("lWhile", ctWhile.getLabel());
CtBlock whileBlock = (CtBlock) ctWhile.getBody();
CtFor forLoop = (CtFor) whileBlock.getStatement(0);
CtBreak breakSwitch = (CtBreak) whileBlock.getStatement(1);
assertEquals("sw", breakSwitch.getTargetLabel());
assertSame(ctSwitch, breakSwitch.getLabelledStatement());
assertEquals("forloop", forLoop.getLabel());
CtBlock forBlock = (CtBlock) forLoop.getBody();
assertEquals(7, forBlock.getStatements().size());
CtIf firstForIf = (CtIf) forBlock.getStatement(1);
CtIf secondForIf = (CtIf) forBlock.getStatement(2);
CtIf thirdForIf = (CtIf) forBlock.getStatement(3);
CtIf fourthForIf = (CtIf) forBlock.getStatement(4);
CtBreak breakItself = (CtBreak) forBlock.getStatement(6);
CtContinue continueFor = (CtContinue) ((CtBlock) firstForIf.getThenStatement()).getStatement(0);
assertSame(forLoop, continueFor.getLabelledStatement());
CtContinue continueWhile = (CtContinue) ((CtBlock) secondForIf.getThenStatement()).getStatement(0);
assertSame(ctWhile, continueWhile.getLabelledStatement());
CtContinue continueDo = (CtContinue) ((CtBlock) thirdForIf.getThenStatement()).getStatement(0);
assertSame(ctDo, continueDo.getLabelledStatement());
CtBreak breakDo = (CtBreak) ((CtBlock) fourthForIf.getThenStatement()).getStatement(0);
assertSame(ctDo, breakDo.getLabelledStatement());
assertEquals("labelbreak", breakItself.getLabel());
assertEquals("labelbreak", breakItself.getTargetLabel());
assertSame(breakItself, breakItself.getLabelledStatement());
}
use of spoon.reflect.code.CtStatement in project spoon by INRIA.
the class IntercessionTest method testInsertAfter.
@Test
public void testInsertAfter() {
CtClass<?> clazz = factory.Code().createCodeSnippetStatement("" + "class X {" + "public void foo() {" + " int x=0;" + " int y=0;" + " int z=x+y;" + "}" + "};").compile();
CtMethod<?> foo = (CtMethod<?>) clazz.getMethods().toArray()[0];
CtBlock<?> body = foo.getBody();
assertEquals(3, body.getStatements().size());
CtStatement s = body.getStatements().get(2);
assertEquals("int z = x + y", s.toString());
// adding a new statement;
CtCodeSnippetStatement stmt = factory.Core().createCodeSnippetStatement();
stmt.setValue("System.out.println(x);");
s.insertAfter(stmt);
assertEquals(4, body.getStatements().size());
assertSame(stmt, body.getStatements().get(3));
}
use of spoon.reflect.code.CtStatement in project spoon by INRIA.
the class ParentTest method testGetParentWithFilter.
@Test
public void testGetParentWithFilter() throws Exception {
// addType should set Parent
CtClass<Foo> clazz = (CtClass<Foo>) factory.Class().getAll().get(0);
CtMethod<Object> m = clazz.getMethod("m");
// get three = "" in one = two = three = "";
CtExpression statement = ((CtAssignment) ((CtAssignment) m.getBody().getStatement(3)).getAssignment()).getAssignment();
CtPackage ctPackage = statement.getParent(new TypeFilter<CtPackage>(CtPackage.class));
assertEquals(Foo.class.getPackage().getName(), ctPackage.getQualifiedName());
CtStatement ctStatement = statement.getParent(new AbstractFilter<CtStatement>(CtStatement.class) {
@Override
public boolean matches(CtStatement element) {
return element.getParent() instanceof CtStatementList && super.matches(element);
}
});
// the filter has to return one = two = three = ""
assertEquals(m.getBody().getStatement(3), ctStatement);
m = clazz.getMethod("internalClass");
CtStatement ctStatement1 = m.getElements(new AbstractFilter<CtStatement>(CtStatement.class) {
@Override
public boolean matches(CtStatement element) {
return element instanceof CtLocalVariable && super.matches(element);
}
}).get(0);
// get the top class
ctStatement1.getParent(CtType.class);
CtType parent = ctStatement1.getParent(new AbstractFilter<CtType>(CtType.class) {
@Override
public boolean matches(CtType element) {
return !element.isAnonymous() && element.isTopLevel() && super.matches(element);
}
});
assertEquals(clazz, parent);
assertNotEquals(ctStatement1.getParent(CtType.class), parent);
// not present element
CtWhile ctWhile = ctStatement1.getParent(new TypeFilter<CtWhile>(CtWhile.class));
assertEquals(null, ctWhile);
CtStatement statementParent = statement.getParent(new AbstractFilter<CtStatement>(CtStatement.class) {
@Override
public boolean matches(CtStatement element) {
return true;
}
});
// getParent must not return the current element
assertNotEquals(statement, statementParent);
}
use of spoon.reflect.code.CtStatement in project spoon by INRIA.
the class PositionTest method defaultConstructorPositionTest.
@Test
public void defaultConstructorPositionTest() throws Exception {
CtClass<Foo> aClass = (CtClass<Foo>) buildClass(Foo.class);
CtConstructor<Foo> defaultConstructor = aClass.getConstructor();
assertEquals(SourcePosition.NOPOSITION, defaultConstructor.getPosition());
CtStatement implicitSuperCall = defaultConstructor.getBody().getStatement(0);
assertTrue(implicitSuperCall.isImplicit());
assertEquals(SourcePosition.NOPOSITION, implicitSuperCall.getPosition());
}
use of spoon.reflect.code.CtStatement in project spoon by INRIA.
the class QualifiedThisRefTest method testPrintCtFieldAccessWorkEvenWhenParentNotInitialized.
@Test
public void testPrintCtFieldAccessWorkEvenWhenParentNotInitialized() throws Exception {
CtClass zeclass = factory.Class().get(QualifiedThisRef.class);
List<CtMethod> methods = zeclass.getMethodsByName("bla");
assertEquals(1, methods.size());
CtStatement invocation = methods.get(0).getBody().getStatement(0);
assertTrue(invocation instanceof CtInvocation);
CtInvocation<?> arg0 = (CtInvocation) invocation;
CtExpression param = arg0.getArguments().get(0);
CtExecutableReference execref = factory.Core().createExecutableReference();
execref.setDeclaringType(factory.Type().createReference("java.util.Map"));
execref.setSimpleName("exorcise");
execref.setStatic(true);
CtTypeReference tmp = param.getType();
CtExpression arg = null;
CtFieldReference ctfe = factory.createFieldReference();
ctfe.setSimpleName("class");
ctfe.setDeclaringType(tmp.box());
arg = factory.Core().createFieldRead();
((CtFieldAccessImpl) arg).setVariable(ctfe);
CtLiteral location = factory.Core().createLiteral();
location.setType(factory.Type().createReference(String.class));
CtTypeReference tmpref = factory.Core().clone(tmp);
CtInvocation invoc = factory.Core().createInvocation();
invoc.setExecutable(execref);
invoc.setArguments(Arrays.asList(new CtExpression[] { param, arg, location }));
execref.setActualTypeArguments(Arrays.asList(new CtTypeReference<?>[] { tmpref }));
// succeeds
arg0.getArguments().set(0, invoc);
DefaultJavaPrettyPrinter printer = new DefaultJavaPrettyPrinter(factory.getEnvironment());
printer.visitCtClass(zeclass);
assertFalse(printer.getResult().isEmpty());
}
Aggregations