/*
* SonarQube Java
* Copyright (C) 2012-2016 SonarSource SA
* mailto:contact AT sonarsource DOT com
*
* This program is free software; you can redistribute it and/or
* modify it under the terms of the GNU Lesser General Public
* License as published by the Free Software Foundation; either
* version 3 of the License, or (at your option) any later version.
*
* This program is distributed in the hope that it will be useful,
* but WITHOUT ANY WARRANTY; without even the implied warranty of
* MERCHANTABILITY or FITNESS FOR A PARTICULAR PURPOSE. See the GNU
* Lesser General Public License for more details.
*
* You should have received a copy of the GNU Lesser General Public License
* along with this program; if not, write to the Free Software Foundation,
* Inc., 51 Franklin Street, Fifth Floor, Boston, MA 02110-1301, USA.
*/
package org.sonar.java.model;
import com.google.common.collect.ImmutableList;
import com.google.common.collect.Iterables;
import com.sonar.sslr.api.typed.ActionParser;
import org.apache.commons.io.FileUtils;
import org.junit.Test;
import org.sonar.java.ast.parser.JavaParser;
import org.sonar.java.ast.parser.TypeParameterListTreeImpl;
import org.sonar.plugins.java.api.tree.AnnotationTree;
import org.sonar.plugins.java.api.tree.ArrayAccessExpressionTree;
import org.sonar.plugins.java.api.tree.ArrayDimensionTree;
import org.sonar.plugins.java.api.tree.ArrayTypeTree;
import org.sonar.plugins.java.api.tree.AssertStatementTree;
import org.sonar.plugins.java.api.tree.AssignmentExpressionTree;
import org.sonar.plugins.java.api.tree.BaseTreeVisitor;
import org.sonar.plugins.java.api.tree.BinaryExpressionTree;
import org.sonar.plugins.java.api.tree.BlockTree;
import org.sonar.plugins.java.api.tree.BreakStatementTree;
import org.sonar.plugins.java.api.tree.CaseGroupTree;
import org.sonar.plugins.java.api.tree.CaseLabelTree;
import org.sonar.plugins.java.api.tree.CatchTree;
import org.sonar.plugins.java.api.tree.ClassTree;
import org.sonar.plugins.java.api.tree.CompilationUnitTree;
import org.sonar.plugins.java.api.tree.ConditionalExpressionTree;
import org.sonar.plugins.java.api.tree.ContinueStatementTree;
import org.sonar.plugins.java.api.tree.DoWhileStatementTree;
import org.sonar.plugins.java.api.tree.EmptyStatementTree;
import org.sonar.plugins.java.api.tree.EnumConstantTree;
import org.sonar.plugins.java.api.tree.ExpressionStatementTree;
import org.sonar.plugins.java.api.tree.ExpressionTree;
import org.sonar.plugins.java.api.tree.ForEachStatement;
import org.sonar.plugins.java.api.tree.ForStatementTree;
import org.sonar.plugins.java.api.tree.IdentifierTree;
import org.sonar.plugins.java.api.tree.IfStatementTree;
import org.sonar.plugins.java.api.tree.ImportClauseTree;
import org.sonar.plugins.java.api.tree.ImportTree;
import org.sonar.plugins.java.api.tree.InstanceOfTree;
import org.sonar.plugins.java.api.tree.LabeledStatementTree;
import org.sonar.plugins.java.api.tree.LambdaExpressionTree;
import org.sonar.plugins.java.api.tree.LiteralTree;
import org.sonar.plugins.java.api.tree.MemberSelectExpressionTree;
import org.sonar.plugins.java.api.tree.MethodInvocationTree;
import org.sonar.plugins.java.api.tree.MethodReferenceTree;
import org.sonar.plugins.java.api.tree.MethodTree;
import org.sonar.plugins.java.api.tree.Modifier;
import org.sonar.plugins.java.api.tree.ModifierKeywordTree;
import org.sonar.plugins.java.api.tree.NewArrayTree;
import org.sonar.plugins.java.api.tree.NewClassTree;
import org.sonar.plugins.java.api.tree.PackageDeclarationTree;
import org.sonar.plugins.java.api.tree.ParameterizedTypeTree;
import org.sonar.plugins.java.api.tree.ParenthesizedTree;
import org.sonar.plugins.java.api.tree.PrimitiveTypeTree;
import org.sonar.plugins.java.api.tree.ReturnStatementTree;
import org.sonar.plugins.java.api.tree.StatementTree;
import org.sonar.plugins.java.api.tree.StaticInitializerTree;
import org.sonar.plugins.java.api.tree.SwitchStatementTree;
import org.sonar.plugins.java.api.tree.SynchronizedStatementTree;
import org.sonar.plugins.java.api.tree.SyntaxToken;
import org.sonar.plugins.java.api.tree.ThrowStatementTree;
import org.sonar.plugins.java.api.tree.Tree;
import org.sonar.plugins.java.api.tree.Tree.Kind;
import org.sonar.plugins.java.api.tree.TryStatementTree;
import org.sonar.plugins.java.api.tree.TypeArguments;
import org.sonar.plugins.java.api.tree.TypeCastTree;
import org.sonar.plugins.java.api.tree.TypeParameterTree;
import org.sonar.plugins.java.api.tree.TypeParameters;
import org.sonar.plugins.java.api.tree.TypeTree;
import org.sonar.plugins.java.api.tree.UnaryExpressionTree;
import org.sonar.plugins.java.api.tree.UnionTypeTree;
import org.sonar.plugins.java.api.tree.VariableTree;
import org.sonar.plugins.java.api.tree.WhileStatementTree;
import org.sonar.plugins.java.api.tree.WildcardTree;
import java.io.File;
import java.nio.charset.StandardCharsets;
import java.util.List;
import static org.assertj.core.api.Assertions.assertThat;
public class JavaTreeModelTest {
private final ActionParser<Tree> p = JavaParser.createParser(StandardCharsets.UTF_8);
@Test
public void line_of_tree() throws Exception {
CompilationUnitTree empty = compilationUnit("");
assertThat(((JavaTree) empty).getLine()).isEqualTo(1);
ClassTree classTree = firstType("class A {}");
assertThat(((JavaTree) classTree).getLine()).isEqualTo(1);
assertThat(((JavaTree) classTree.modifiers()).getLine()).isEqualTo(-1);
}
@Test
public void integration_test() {
Iterable<File> files = Iterables.concat(
FileUtils.listFiles(new File("src/main/java/"), new String[]{"java"}, true),
FileUtils.listFiles(new File("src/test/java/"), new String[]{"java"}, true),
FileUtils.listFiles(new File("src/test/files/"), new String[]{"java"}, true)
);
BaseTreeVisitor visitor = new BaseTreeVisitor();
for (File file : files) {
Tree tree = p.parse(file);
tree.accept(visitor);
}
}
@Test
public void explicit_generic_invocation() {
p.parse("class A { void f() { <A>foo(); } }");
}
@Test
public void basic_type() {
PrimitiveTypeTree tree = (PrimitiveTypeTree) ((MethodTree) firstTypeMember("class T { int m() { return null; } }")).returnType();
assertThat(tree.keyword().text()).isEqualTo("int");
assertThatChildrenIteratorHasSize(tree, 1);
tree = (PrimitiveTypeTree) ((MethodTree) firstTypeMember("class T { void m() { return null; } }")).returnType();
assertThat(tree.keyword().text()).isEqualTo("void");
assertThatChildrenIteratorHasSize(tree, 1);
}
@Test
public void type() {
ArrayTypeTree tree = (ArrayTypeTree) ((MethodTree) firstTypeMember("class T { int[] m() { return null; } }")).returnType();
assertThat(tree.type()).isInstanceOf(PrimitiveTypeTree.class);
}
@Test
public void literal() {
LiteralTree tree = (LiteralTree) expressionOfReturnStatement("class T { int m() { return 1; } }");
assertThat(tree.is(Tree.Kind.INT_LITERAL)).isTrue();
assertThat(tree.value()).isEqualTo("1");
assertThatChildrenIteratorHasSize(tree, 1);
SyntaxToken token = tree.token();
assertThat(token).isNotNull();
assertThat(token.line()).isEqualTo(1);
assertThat(token.column()).isEqualTo(27);
tree = (LiteralTree) expressionOfReturnStatement("class T { long m() { return 1L; } }");
assertThat(tree.is(Tree.Kind.LONG_LITERAL)).isTrue();
assertThat(tree.value()).isEqualTo("1L");
assertThatChildrenIteratorHasSize(tree, 1);
token = tree.token();
assertThat(token).isNotNull();
assertThat(token.line()).isEqualTo(1);
assertThat(token.column()).isEqualTo(28);
tree = (LiteralTree) expressionOfReturnStatement("class T { float m() { return 1F; } }");
assertThat(tree.is(Tree.Kind.FLOAT_LITERAL)).isTrue();
assertThat(tree.value()).isEqualTo("1F");
assertThatChildrenIteratorHasSize(tree, 1);
token = tree.token();
assertThat(token).isNotNull();
assertThat(token.line()).isEqualTo(1);
assertThat(token.column()).isEqualTo(29);
tree = (LiteralTree) expressionOfReturnStatement("class T { double m() { return 1d; } }");
assertThat(tree.is(Tree.Kind.DOUBLE_LITERAL)).isTrue();
assertThat(tree.value()).isEqualTo("1d");
assertThatChildrenIteratorHasSize(tree, 1);
token = tree.token();
assertThat(token).isNotNull();
assertThat(token.line()).isEqualTo(1);
assertThat(token.column()).isEqualTo(30);
tree = (LiteralTree) expressionOfReturnStatement("class T { boolean m() { return true; } }");
assertThat(tree.is(Tree.Kind.BOOLEAN_LITERAL)).isTrue();
assertThat(tree.value()).isEqualTo("true");
assertThatChildrenIteratorHasSize(tree, 1);
token = tree.token();
assertThat(token).isNotNull();
assertThat(token.line()).isEqualTo(1);
assertThat(token.column()).isEqualTo(31);
tree = (LiteralTree) expressionOfReturnStatement("class T { boolean m() { return false; } }");
assertThat(tree.is(Tree.Kind.BOOLEAN_LITERAL)).isTrue();
assertThat(tree.value()).isEqualTo("false");
assertThatChildrenIteratorHasSize(tree, 1);
token = tree.token();
assertThat(token).isNotNull();
assertThat(token.line()).isEqualTo(1);
assertThat(token.column()).isEqualTo(31);
tree = (LiteralTree) expressionOfReturnStatement("class T { char m() { return 'c'; } }");
assertThat(tree.is(Tree.Kind.CHAR_LITERAL)).isTrue();
assertThat(tree.value()).isEqualTo("'c'");
assertThatChildrenIteratorHasSize(tree, 1);
token = tree.token();
assertThat(token).isNotNull();
assertThat(token.line()).isEqualTo(1);
assertThat(token.column()).isEqualTo(28);
tree = (LiteralTree) expressionOfReturnStatement("class T { String m() { return \"s\"; } }");
assertThat(tree.is(Tree.Kind.STRING_LITERAL)).isTrue();
assertThat(tree.value()).isEqualTo("\"s\"");
assertThatChildrenIteratorHasSize(tree, 1);
token = tree.token();
assertThat(token).isNotNull();
assertThat(token.line()).isEqualTo(1);
assertThat(token.column()).isEqualTo(30);
tree = (LiteralTree) expressionOfReturnStatement("class T { Object m() { return null; } }");
assertThat(tree.is(Tree.Kind.NULL_LITERAL)).isTrue();
assertThat(tree.value()).isEqualTo("null");
assertThatChildrenIteratorHasSize(tree, 1);
token = tree.token();
assertThat(token).isNotNull();
assertThat(token.line()).isEqualTo(1);
assertThat(token.column()).isEqualTo(30);
}
@Test
public void compilation_unit() {
CompilationUnitTree tree = compilationUnit("import foo; import bar; class Foo {} class Bar {}");
assertThat(tree.is(Tree.Kind.COMPILATION_UNIT)).isTrue();
assertThat(tree.packageDeclaration()).isNull();
assertThat(tree.imports()).hasSize(2);
assertThat(tree.types()).hasSize(2);
assertThatChildrenIteratorHasSize(tree, 5);
tree = compilationUnit("package pkg; import foo; import bar; class Foo {} class Bar {}");
assertThat(tree.is(Tree.Kind.COMPILATION_UNIT)).isTrue();
assertThat(tree.packageDeclaration()).isNotNull();
assertThat(tree.imports()).hasSize(2);
assertThat(tree.types()).hasSize(2);
assertThatChildrenIteratorHasSize(tree, 6);
tree = compilationUnit("import foo; ; import bar; class Foo {} class Bar {}");
assertThat(tree.is(Tree.Kind.COMPILATION_UNIT)).isTrue();
assertThat(tree.packageDeclaration()).isNull();
assertThat(tree.imports()).hasSize(3);
assertThat(tree.imports().get(1).is(Kind.EMPTY_STATEMENT)).isTrue();
assertThat(tree.types()).hasSize(2);
assertThatChildrenIteratorHasSize(tree, 6);
}
@Test
public void package_declaration() {
PackageDeclarationTree tree = compilationUnit("package myPackage;").packageDeclaration();
assertThat(tree.is(Tree.Kind.PACKAGE)).isTrue();
assertThat(tree.annotations()).isEmpty();
assertThat(tree.packageKeyword().text()).isEqualTo("package");
assertThat(tree.packageName()).isNotNull();
assertThat(tree.packageName().is(Tree.Kind.IDENTIFIER)).isTrue();
assertThat(tree.semicolonToken().text()).isEqualTo(";");
assertThatChildrenIteratorHasSize(tree, 3);
tree = compilationUnit("@Foo @Bar package org.myPackage;").packageDeclaration();
assertThat(tree.is(Tree.Kind.PACKAGE)).isTrue();
assertThat(tree.annotations()).hasSize(2);
assertThat(tree.packageKeyword().text()).isEqualTo("package");
assertThat(tree.packageName()).isNotNull();
assertThat(tree.packageName().is(Tree.Kind.MEMBER_SELECT)).isTrue();
assertThat(tree.semicolonToken().text()).isEqualTo(";");
assertThatChildrenIteratorHasSize(tree, 5);
}
@Test
public void import_declaration() {
ImportClauseTree tree = compilationUnit(";").imports().get(0);
assertThat(tree.is(Kind.EMPTY_STATEMENT)).isTrue();
assertThat(tree.is(Kind.IMPORT)).isFalse();
tree = compilationUnit("import foo.Bar;").imports().get(0);
assertThat(tree.is(Kind.IMPORT)).isTrue();
ImportTree importTree = (ImportTree) tree;
assertThat(importTree.isStatic()).isFalse();
assertThat(importTree.qualifiedIdentifier()).isNotNull();
assertThatChildrenIteratorHasSize(importTree, 3);
tree = compilationUnit("import foo.bar.*;").imports().get(0);
assertThat(tree.is(Kind.IMPORT)).isTrue();
importTree = (ImportTree) tree;
assertThat(importTree.isStatic()).isFalse();
assertThat(importTree.qualifiedIdentifier()).isNotNull();
assertThatChildrenIteratorHasSize(importTree, 3);
tree = compilationUnit("import static foo.Bar.method;").imports().get(0);
assertThat(tree.is(Kind.IMPORT)).isTrue();
importTree = (ImportTree) tree;
assertThat(importTree.isStatic()).isTrue();
assertThat(importTree.qualifiedIdentifier()).isNotNull();
assertThatChildrenIteratorHasSize(importTree, 4);
tree = compilationUnit("import static foo.Bar.*;").imports().get(0);
assertThat(tree.is(Kind.IMPORT)).isTrue();
importTree = (ImportTree) tree;
assertThat(importTree.isStatic()).isTrue();
assertThat(importTree.qualifiedIdentifier()).isNotNull();
assertThatChildrenIteratorHasSize(importTree, 4);
}
/**
* 4.5.1. Type Arguments and Wildcards
*/
@Test
public void type_arguments() {
VariableTree variableTree = (VariableTree) firstMethodFirstStatement("public class T { void m() { ClassType<? extends A, ? super B, ?, C> var; } }");
assertThatChildrenIteratorHasSize(variableTree, 4);
ParameterizedTypeTree parameterizedTypeTree = (ParameterizedTypeTree) variableTree.type();
assertThatChildrenIteratorHasSize(parameterizedTypeTree, 2);
TypeArguments typeArguments = parameterizedTypeTree.typeArguments();
assertThat(typeArguments).hasSize(4);
assertThat(typeArguments.separators()).hasSize(3);
assertThatChildrenIteratorHasSize(typeArguments, 9);
WildcardTree wildcard = (WildcardTree) typeArguments.get(0);
assertThat(wildcard.is(Tree.Kind.EXTENDS_WILDCARD)).isTrue();
assertThat(wildcard.bound()).isInstanceOf(IdentifierTree.class);
assertThat(wildcard.queryToken()).isNotNull();
assertThat(wildcard.queryToken().text()).isEqualTo("?");
assertThat(wildcard.extendsOrSuperToken()).isNotNull();
assertThat(wildcard.extendsOrSuperToken().text()).isEqualTo("extends");
assertThatChildrenIteratorHasSize(wildcard, 3);
wildcard = (WildcardTree) typeArguments.get(1);
assertThat(wildcard.is(Tree.Kind.SUPER_WILDCARD)).isTrue();
assertThat(wildcard.bound()).isInstanceOf(IdentifierTree.class);
assertThat(wildcard.queryToken()).isNotNull();
assertThat(wildcard.queryToken().text()).isEqualTo("?");
assertThat(wildcard.extendsOrSuperToken()).isNotNull();
assertThat(wildcard.extendsOrSuperToken().text()).isEqualTo("super");
assertThatChildrenIteratorHasSize(wildcard, 3);
wildcard = (WildcardTree) typeArguments.get(2);
assertThat(wildcard.is(Tree.Kind.UNBOUNDED_WILDCARD)).isTrue();
assertThat(wildcard.bound()).isNull();
assertThat(wildcard.queryToken().text()).isEqualTo("?");
assertThat(wildcard.queryToken()).isNotNull();
assertThat(wildcard.extendsOrSuperToken()).isNull();
assertThatChildrenIteratorHasSize(wildcard, 1);
assertThat(typeArguments.get(3)).isInstanceOf(IdentifierTree.class);
variableTree = (VariableTree) firstMethodFirstStatement("public class T { void m() { ClassType<@Foo ? extends A> var; } }");
parameterizedTypeTree = (ParameterizedTypeTree) variableTree.type();
assertThatChildrenIteratorHasSize(parameterizedTypeTree, 2);
typeArguments = parameterizedTypeTree.typeArguments();
assertThatChildrenIteratorHasSize(typeArguments, 3);
wildcard = (WildcardTree) typeArguments.get(0);
assertThat(wildcard.is(Tree.Kind.EXTENDS_WILDCARD)).isTrue();
assertThat(wildcard.bound()).isInstanceOf(IdentifierTree.class);
assertThat(wildcard.queryToken().text()).isEqualTo("?");
assertThat(wildcard.annotations()).hasSize(1);
assertThat(wildcard.extendsOrSuperToken().text()).isEqualTo("extends");
assertThatChildrenIteratorHasSize(wildcard, 4);
variableTree = (VariableTree) firstMethodFirstStatement("public class T { void m() { ClassType<? extends @Foo @Bar A> var; } }");
parameterizedTypeTree = (ParameterizedTypeTree) variableTree.type();
assertThatChildrenIteratorHasSize(parameterizedTypeTree, 2);
typeArguments = parameterizedTypeTree.typeArguments();
assertThatChildrenIteratorHasSize(typeArguments, 3);
wildcard = (WildcardTree) typeArguments.get(0);
assertThat(wildcard.is(Tree.Kind.EXTENDS_WILDCARD)).isTrue();
assertThat(wildcard.bound()).isInstanceOf(IdentifierTree.class);
assertThat(wildcard.annotations()).isEmpty();
assertThat(wildcard.queryToken().text()).isEqualTo("?");
assertThat(wildcard.extendsOrSuperToken().text()).isEqualTo("extends");
assertThatChildrenIteratorHasSize(wildcard, 3);
}
/*
* 8. Classes
*/
@Test
public void class_declaration() {
ClassTree tree = firstType("public class T<U> extends C implements I1, I2 { }");
assertThat(tree.is(Tree.Kind.CLASS)).isTrue();
List<ModifierKeywordTree> modifiers = tree.modifiers().modifiers();
assertThat(modifiers).hasSize(1);
assertThat(modifiers.get(0).modifier()).isEqualTo(Modifier.PUBLIC);
assertThat(modifiers.get(0).keyword().text()).isEqualTo("public");
assertThat(tree.simpleName().name()).isEqualTo("T");
TypeParameters typeParameters = tree.typeParameters();
assertThat(typeParameters).isNotEmpty();
assertThat(typeParameters.separators()).isEmpty();
assertThatChildrenIteratorHasSize(typeParameters, 3);
assertThat(tree.openBraceToken().text()).isEqualTo("{");
assertThat(tree.superClass()).isNotNull();
assertThat(tree.superInterfaces()).hasSize(2);
assertThat(tree.superInterfaces().separators()).hasSize(1);
assertThat(tree.superInterfaces().separators().get(0).text()).isEqualTo(",");
assertThat(tree.closeBraceToken().text()).isEqualTo("}");
assertThat(tree.declarationKeyword().text()).isEqualTo("class");
tree = firstType("public class T { }");
modifiers = tree.modifiers().modifiers();
assertThat(modifiers).hasSize(1);
assertThat(modifiers.get(0).modifier()).isEqualTo(Modifier.PUBLIC);
assertThat(modifiers.get(0).keyword().text()).isEqualTo("public");
assertThat(tree.simpleName().name()).isEqualTo("T");
assertThat(tree.typeParameters()).isEmpty();
assertThat(tree.superClass()).isNull();
assertThat(tree.superInterfaces()).isEmpty();
assertThat(tree.declarationKeyword().text()).isEqualTo("class");
tree = firstType("class T<U,V> { }");
assertThat(tree.modifiers()).isEmpty();
assertThat(tree.simpleName().name()).isEqualTo("T");
typeParameters = tree.typeParameters();
assertThat(typeParameters).hasSize(2);
assertThat(typeParameters.separators()).hasSize(1);
assertThatChildrenIteratorHasSize(typeParameters, 5);
assertThat(tree.superClass()).isNull();
assertThat(tree.superInterfaces()).isEmpty();
assertThat(tree.declarationKeyword().text()).isEqualTo("class");
tree = firstType("@Deprecated class T { }");
assertThat(tree.is(Tree.Kind.CLASS)).isTrue();
assertThat(tree.modifiers().annotations()).hasSize(1);
assertThat(tree.declarationKeyword().text()).isEqualTo("class");
}
@Test
public void annotations() {
ClassTree tree = firstType("@SuppressWarnings(\"unchecked\") class T { }");
List<AnnotationTree> annotations = tree.modifiers().annotations();
assertThat(annotations).hasSize(1);
AnnotationTree annotation = annotations.get(0);
assertThat(annotation.annotationType().is(Tree.Kind.IDENTIFIER)).isTrue();
assertThat(annotation.arguments().openParenToken()).isNotNull();
assertThat(annotation.arguments().separators()).isEmpty();
assertThat(annotation.arguments()).hasSize(1);
assertThat(annotation.arguments().get(0).is(Tree.Kind.STRING_LITERAL)).isTrue();
assertThat(annotation.arguments().closeParenToken()).isNotNull();
assertThat(annotation.atToken()).isNotNull();
assertThatChildrenIteratorHasSize(annotation, 3);
tree = firstType("@Target( ) class U {}");
annotations = tree.modifiers().annotations();
assertThat(annotations).hasSize(1);
annotation = annotations.get(0);
assertThat(annotation.arguments().openParenToken()).isNotNull();
assertThat(annotation.arguments()).isEmpty();
assertThat(annotation.arguments().separators()).isEmpty();
assertThat(annotation.arguments().closeParenToken()).isNotNull();
assertThat(annotation.atToken()).isNotNull();
assertThatChildrenIteratorHasSize(annotation, 3);
tree = firstType("@Target({ElementType.METHOD}) class U {}");
annotations = tree.modifiers().annotations();
assertThat(annotations).hasSize(1);
annotation = annotations.get(0);
assertThat(annotation.arguments().openParenToken()).isNotNull();
assertThat(annotation.arguments()).hasSize(1);
assertThat(annotation.arguments().get(0).is(Tree.Kind.NEW_ARRAY)).isTrue();
assertThat(annotation.arguments().separators()).isEmpty();
assertThat(annotation.arguments().closeParenToken()).isNotNull();
assertThat(annotation.atToken()).isNotNull();
assertThatChildrenIteratorHasSize(annotation, 3);
tree = firstType("@SuppressWarnings({\"hello\",}) class U {}");
annotations = tree.modifiers().annotations();
assertThat(annotations).hasSize(1);
annotation = annotations.get(0);
assertThat(annotation.arguments().openParenToken()).isNotNull();
assertThat(annotation.arguments()).hasSize(1);
assertThat(annotation.arguments().get(0).is(Tree.Kind.NEW_ARRAY)).isTrue();
NewArrayTree arg = (NewArrayTree) annotation.arguments().get(0);
assertThat(arg.initializers()).hasSize(1);
assertThat(arg.initializers().get(0).is(Tree.Kind.STRING_LITERAL)).isTrue();
assertThat(arg.initializers().separators()).hasSize(1);
assertThat(annotation.arguments().closeParenToken()).isNotNull();
assertThat(annotation.atToken()).isNotNull();
assertThatChildrenIteratorHasSize(annotation, 3);
tree = firstType("@Target(value={ElementType.METHOD}, value2=\"toto\") class T { }");
annotations = tree.modifiers().annotations();
assertThat(annotations).hasSize(1);
annotation = annotations.get(0);
assertThat(annotation.annotationType().is(Tree.Kind.IDENTIFIER)).isTrue();
assertThat(annotation.arguments().openParenToken()).isNotNull();
assertThat(annotation.arguments()).hasSize(2);
assertThat(annotation.arguments().separators()).hasSize(1);
assertThat(annotation.arguments().get(0).is(Tree.Kind.ASSIGNMENT)).isTrue();
assertThat(annotation.arguments().closeParenToken()).isNotNull();
assertThat(annotation.atToken()).isNotNull();
assertThatChildrenIteratorHasSize(annotation, 3);
VariableTree variable = (VariableTree) firstMethodFirstStatement("class T { private void meth() { @NonNullable String str;}}");
assertThatChildrenIteratorHasSize(variable, 4);
annotations = variable.modifiers().annotations();
assertThat(annotations).hasSize(1);
annotation = annotations.get(0);
assertThat(annotation.annotationType().is(Tree.Kind.IDENTIFIER)).isTrue();
assertThat(annotation.atToken()).isNotNull();
assertThat(annotation.arguments()).isEmpty();
assertThatChildrenIteratorHasSize(annotation, 3);
annotations = compilationUnit("@PackageLevelAnnotation package blammy;").packageDeclaration().annotations();
assertThat(annotations).hasSize(1);
assertThat(annotations.get(0).atToken()).isNotNull();
assertThat(annotation.arguments()).isEmpty();
assertThatChildrenIteratorHasSize(annotation, 3);
variable = (VariableTree) firstMethodFirstStatement("class T { private void m() { @Foo Integer foo; } }");
assertThat(variable.modifiers().annotations()).hasSize(1);
assertThat(variable.type().is(Tree.Kind.IDENTIFIER)).isTrue();
assertThat(variable.type().annotations()).isEmpty();
assertThatChildrenIteratorHasSize(variable, 4);
variable = (VariableTree) firstMethodFirstStatement("class T { private void m() { @Foo java.lang.Integer foo; } }");
assertThat(variable.modifiers().annotations()).hasSize(1);
assertThat(variable.type().is(Tree.Kind.MEMBER_SELECT)).isTrue();
assertThat(variable.type().annotations()).isEmpty();
assertThatChildrenIteratorHasSize(variable, 4);
variable = (VariableTree) firstMethodFirstStatement("class T { private void m() { java.lang.@Foo Integer foo; } }");
assertThat(variable.modifiers()).isEmpty();
assertThat(variable.type().is(Tree.Kind.MEMBER_SELECT)).isTrue();
assertThat(variable.type().annotations()).isEmpty();
assertThatChildrenIteratorHasSize(variable, 4);
assertThat(((MemberSelectExpressionTree) variable.type()).identifier().annotations()).hasSize(1);
variable = (VariableTree) firstMethodFirstStatement("class T { private void m() { a.B.C foo = a.B.new @Foo C(); } }");
assertThat(variable.modifiers()).isEmpty();
assertThatChildrenIteratorHasSize(variable, 6);
TypeTree type = ((NewClassTree) variable.initializer()).identifier();
assertThat(type.is(Tree.Kind.IDENTIFIER)).isTrue();
assertThat(type.annotations()).hasSize(1);
assertThatChildrenIteratorHasSize(type, 2);
variable = (VariableTree) firstMethodFirstStatement("class T { private void m() { a.b.C<Integer> foo = a.B.new @Foo C<Integer>(); } }");
assertThat(variable.modifiers()).isEmpty();
assertThatChildrenIteratorHasSize(variable, 6);
type = ((NewClassTree) variable.initializer()).identifier();
assertThat(type.is(Tree.Kind.PARAMETERIZED_TYPE)).isTrue();
assertThat(type.annotations()).hasSize(1);
assertThatChildrenIteratorHasSize(type, 3);
variable = (VariableTree) firstMethodFirstStatement("class T { private void m() { a.B.C foo = new @Foo a.B.C(); } }");
assertThat(variable.modifiers()).isEmpty();
assertThatChildrenIteratorHasSize(variable, 6);
type = ((NewClassTree) variable.initializer()).identifier();
assertThat(type.is(Tree.Kind.MEMBER_SELECT)).isTrue();
assertThat(type.annotations()).hasSize(1);
assertThatChildrenIteratorHasSize(type, 4);
variable = (VariableTree) firstMethodFirstStatement("class T { private void m() { a.b.C<Integer> foo = new @Foo a.b.C<Integer>(); } }");
assertThat(variable.modifiers()).isEmpty();
assertThatChildrenIteratorHasSize(variable, 6);
type = ((NewClassTree) variable.initializer()).identifier();
assertThat(type.is(Tree.Kind.PARAMETERIZED_TYPE)).isTrue();
assertThat(type.annotations()).hasSize(1);
assertThatChildrenIteratorHasSize(type, 3);
variable = (VariableTree) firstMethodFirstStatement("class T { private void m() { int[] foo = new @Foo int[42]; } }");
assertThat(variable.modifiers()).isEmpty();
assertThatChildrenIteratorHasSize(variable, 6);
type = ((NewArrayTree) variable.initializer()).type();
assertThat(type.is(Tree.Kind.PRIMITIVE_TYPE)).isTrue();
assertThat(type.annotations()).hasSize(1);
assertThatChildrenIteratorHasSize(type, 2);
variable = ((TryStatementTree) firstMethodFirstStatement("class T { private void m() { try{ } catch (@Foo E1 | E2 e) {}; } }")).catches().get(0).parameter();
assertThat(variable.modifiers()).hasSize(1);
assertThatChildrenIteratorHasSize(variable, 3);
type = variable.type();
assertThat(type.is(Tree.Kind.UNION_TYPE)).isTrue();
assertThat(type.annotations()).isEmpty();
assertThat(((UnionTypeTree) type).typeAlternatives().separators()).hasSize(1);
assertThatChildrenIteratorHasSize(type, 1);
ClassTree classTree = firstType("class T extends @Foo a.b.C {}");
assertThat(classTree.modifiers()).isEmpty();
assertThatChildrenIteratorHasSize(classTree, 9);
type = classTree.superClass();
assertThat(type.is(Tree.Kind.MEMBER_SELECT)).isTrue();
assertThat(type.annotations()).hasSize(1);
assertThatChildrenIteratorHasSize(type, 4);
classTree = firstType("class T extends @Foo a.b.C<Integer> {}");
assertThat(classTree.modifiers()).isEmpty();
assertThatChildrenIteratorHasSize(classTree, 9);
type = classTree.superClass();
assertThat(type.is(Tree.Kind.PARAMETERIZED_TYPE)).isTrue();
assertThat(type.annotations()).hasSize(1);
assertThatChildrenIteratorHasSize(type, 3);
classTree = (ClassTree) firstMethodFirstStatement("class MyClass<A, B, C> { void foo() { class MyOtherClass extends @Foo MyClass<A, B, C>.MyInnerClass {} } public class MyInnerClass {}}");
assertThat(classTree.modifiers()).isEmpty();
assertThatChildrenIteratorHasSize(classTree, 9);
type = classTree.superClass();
assertThat(type.is(Tree.Kind.MEMBER_SELECT)).isTrue();
assertThat(type.annotations()).hasSize(1);
type = (ParameterizedTypeTree) ((MemberSelectExpressionTree) type).expression();
assertThat(type.is(Tree.Kind.PARAMETERIZED_TYPE)).isTrue();
assertThat(type.annotations()).hasSize(0);
assertThatChildrenIteratorHasSize(type, 2);
TypeCastTree typeCast = (TypeCastTree) ((ReturnStatementTree) firstMethodFirstStatement("class T { private long m(int a) { return (@Foo long) a; } }")).expression();
assertThat(typeCast.type()).isNotNull();
assertThatChildrenIteratorHasSize(typeCast, 5);
type = typeCast.type();
assertThat(type.is(Tree.Kind.PRIMITIVE_TYPE)).isTrue();
assertThat(type.annotations()).hasSize(1);
assertThatChildrenIteratorHasSize(type, 2);
}
@Test
public void class_init_declaration() {
BlockTree tree = (BlockTree) firstTypeMember("class T { { ; ; } }");
assertThat(tree.is(Tree.Kind.INITIALIZER)).isTrue();
assertThat(tree.body()).hasSize(2);
assertThat(tree.openBraceToken().text()).isEqualTo("{");
assertThat(tree.closeBraceToken().text()).isEqualTo("}");
assertThatChildrenIteratorHasSize(tree, 4);
tree = (BlockTree) firstTypeMember("class T { static { ; ; } }");
assertThat(tree.is(Tree.Kind.STATIC_INITIALIZER)).isTrue();
StaticInitializerTree staticInitializerTree = (StaticInitializerTree) tree;
assertThat(staticInitializerTree.body()).hasSize(2);
assertThat(staticInitializerTree.staticKeyword().text()).isEqualTo("static");
assertThat(staticInitializerTree.openBraceToken().text()).isEqualTo("{");
assertThat(staticInitializerTree.closeBraceToken().text()).isEqualTo("}");
assertThatChildrenIteratorHasSize(tree, 5);
}
@Test
public void class_constructor() {
MethodTree tree = (MethodTree) firstTypeMember("class T { T(int p1, int... p2) throws Exception1, Exception2 {} }");
assertThat(tree.is(Tree.Kind.CONSTRUCTOR)).isTrue();
assertThat(tree.returnType()).isNull();
assertThat(tree.simpleName().name()).isEqualTo("T");
assertThat(tree.parameters()).hasSize(2);
assertThat(tree.parameters().get(0).type()).isInstanceOf(PrimitiveTypeTree.class);
assertThat(tree.parameters().get(1).type()).isInstanceOf(ArrayTypeTree.class);
assertThat(tree.throwsClauses()).hasSize(2);
assertThat(tree.throwsClauses().separators()).hasSize(1);
assertThat(tree.block()).isNotNull();
assertThat(tree.defaultValue()).isNull();
assertThatChildrenIteratorHasSize(tree, 10);
}
@Test
public void class_field() {
List<Tree> declarations = firstType("class T { public int f1 = 42, f2[]; }").members();
assertThat(declarations).hasSize(2);
VariableTree tree = (VariableTree) declarations.get(0);
assertThat(tree.is(Tree.Kind.VARIABLE)).isTrue();
assertThat(tree.modifiers().modifiers()).hasSize(1);
assertThat(tree.modifiers().modifiers().get(0).modifier()).isEqualTo(Modifier.PUBLIC);
assertThat(tree.type()).isInstanceOf(PrimitiveTypeTree.class);
assertThat(tree.simpleName().name()).isEqualTo("f1");
assertThat(tree.initializer()).isNotNull();
assertThat(tree.endToken()).isNotNull();
assertThat(tree.endToken().text()).isEqualTo(",");
assertThatChildrenIteratorHasSize(tree, 6);
tree = (VariableTree) declarations.get(1);
assertThat(tree.is(Tree.Kind.VARIABLE)).isTrue();
assertThat(tree.modifiers().modifiers()).hasSize(1);
assertThat(tree.modifiers().modifiers().get(0).modifier()).isEqualTo(Modifier.PUBLIC);
assertThat(tree.type()).isInstanceOf(ArrayTypeTree.class);
assertThatArrayTypeHasBrackets((ArrayTypeTree) tree.type());
assertThat(tree.simpleName().name()).isEqualTo("f2");
assertThat(tree.initializer()).isNull();
assertThat(tree.endToken()).isNotNull();
assertThat(tree.endToken().text()).isEqualTo(";");
assertThatChildrenIteratorHasSize(tree, 4);
}
@Test
public void class_method() {
MethodTree tree = (MethodTree) firstTypeMember("class T { public int m(int p[][]){} }");
assertThat(tree.is(Tree.Kind.METHOD)).isTrue();
assertThat(tree.parameters()).hasSize(1);
assertThat(tree.parameters().get(0).type()).isInstanceOf(ArrayTypeTree.class);
assertThatChildrenIteratorHasSize(tree, 8);
assertThat(((ArrayTypeTree) tree.parameters().get(0).type()).type()).isInstanceOf(ArrayTypeTree.class);
tree = (MethodTree) firstTypeMember("class T { public <T> int m(@Annotate int p1, int... p2) throws Exception1, Exception2 {} }");
assertThat(tree.is(Tree.Kind.METHOD)).isTrue();
assertThat(tree.modifiers().modifiers()).hasSize(1);
assertThat(tree.modifiers().modifiers().get(0).modifier()).isEqualTo(Modifier.PUBLIC);
assertThat(tree.typeParameters()).isNotEmpty();
assertThat(tree.returnType()).isNotNull();
assertThat(tree.simpleName().name()).isEqualTo("m");
assertThat(tree.parameters()).hasSize(2);
assertThat(tree.parameters().get(0).type()).isInstanceOf(PrimitiveTypeTree.class);
assertThat(tree.parameters().get(0).modifiers().annotations()).hasSize(1);
assertThat(tree.parameters().get(1).type()).isInstanceOf(ArrayTypeTree.class);
assertThat(tree.parameters().get(1).endToken()).isNull();
assertThat(tree.throwsClauses()).hasSize(2);
assertThat(tree.throwsClauses().separators()).hasSize(1);
assertThat(tree.block()).isNotNull();
assertThat(tree.defaultValue()).isNull();
assertThatChildrenIteratorHasSize(tree, 11);
// void method
tree = (MethodTree) firstTypeMember("class T { public void m(int p) throws Exception1, Exception2 {} }");
assertThat(tree.is(Tree.Kind.METHOD)).isTrue();
assertThat(tree.modifiers().modifiers()).hasSize(1);
assertThat(tree.modifiers().modifiers().get(0).modifier()).isEqualTo(Modifier.PUBLIC);
assertThat(tree.typeParameters()).isEmpty();
assertThat(tree.returnType()).isNotNull();
assertThat(tree.simpleName().name()).isEqualTo("m");
assertThat(tree.parameters()).hasSize(1);
assertThat(tree.parameters().get(0).endToken()).isNull();
assertThat(tree.throwsClauses()).hasSize(2);
assertThat(tree.block()).isNotNull();
assertThat(tree.defaultValue()).isNull();
assertThatChildrenIteratorHasSize(tree, 10);
tree = (MethodTree) firstTypeMember("class T { public int[] m(int p1, int... p2)[] throws Exception1, Exception2 {} }");
assertThat(tree.is(Tree.Kind.METHOD)).isTrue();
assertThat(tree.modifiers().modifiers()).hasSize(1);
assertThat(tree.modifiers().modifiers().get(0).modifier()).isEqualTo(Modifier.PUBLIC);
assertThat(tree.returnType()).isNotNull();
assertThat(tree.returnType().is(Tree.Kind.ARRAY_TYPE)).isTrue();
assertThat(((ArrayTypeTree) tree.returnType()).type().is(Kind.ARRAY_TYPE)).isTrue();
assertThat(((ArrayTypeTree) ((ArrayTypeTree) tree.returnType()).type()).type().is(Kind.PRIMITIVE_TYPE)).isTrue();
assertThat(tree.simpleName().name()).isEqualTo("m");
assertThat(tree.parameters()).hasSize(2);
assertThat(tree.parameters().get(0).type()).isInstanceOf(PrimitiveTypeTree.class);
assertThat(tree.parameters().get(1).type()).isInstanceOf(ArrayTypeTree.class);
assertThat(tree.throwsClauses()).hasSize(2);
assertThat(tree.throwsClauses().separators()).hasSize(1);
assertThat(tree.block()).isNotNull();
assertThat(tree.defaultValue()).isNull();
assertThatChildrenIteratorHasSize(tree, 11);
tree = (MethodTree) firstTypeMember("class T { public int m()[] { return null; } }");
assertThat(tree.is(Tree.Kind.METHOD)).isTrue();
assertThat(tree.parameters()).isEmpty();
assertThat(tree.returnType().is(Kind.ARRAY_TYPE)).isTrue();
assertThat(tree.returnType().is(Kind.PRIMITIVE_TYPE)).isFalse();
assertThatChildrenIteratorHasSize(tree, 7);
}
/*
* 8.9. Enums
*/
@Test
public void enum_declaration() {
ClassTree tree = firstType("public enum T implements I1, I2 { }");
assertThat(tree.is(Tree.Kind.ENUM)).isTrue();
assertThat(tree.modifiers().modifiers()).hasSize(1);
assertThat(tree.modifiers().modifiers().get(0).modifier()).isEqualTo(Modifier.PUBLIC);
assertThat(tree.simpleName().name()).isEqualTo("T");
assertThat(tree.superClass()).isNull();
assertThat(tree.superInterfaces()).hasSize(2);
assertThat(tree.declarationKeyword().text()).isEqualTo("enum");
assertThatChildrenIteratorHasSize(tree, 8);
tree = firstType("public enum T { }");
assertThat(tree.is(Tree.Kind.ENUM)).isTrue();
assertThat(tree.modifiers().modifiers()).hasSize(1);
assertThat(tree.modifiers().modifiers().get(0).modifier()).isEqualTo(Modifier.PUBLIC);
assertThat(tree.simpleName().name()).isEqualTo("T");
assertThat(tree.superClass()).isNull();
assertThat(tree.openBraceToken().text()).isEqualTo("{");
assertThat(tree.closeBraceToken().text()).isEqualTo("}");
assertThat(tree.superInterfaces()).isEmpty();
assertThat(tree.declarationKeyword().text()).isEqualTo("enum");
assertThatChildrenIteratorHasSize(tree, 7);
}
@Test
public void enum_constant() {
List<Tree> declarations = firstType("enum T { C1, C2(2) { }; }").members();
assertThat(declarations).hasSize(2);
EnumConstantTree tree = (EnumConstantTree) declarations.get(0);
assertThat(tree.is(Tree.Kind.ENUM_CONSTANT)).isTrue();
assertThat(tree.simpleName().name()).isEqualTo("C1");
assertThat(tree.separatorToken().text()).isEqualTo(",");
assertThatChildrenIteratorHasSize(tree, 3);
NewClassTree newClassTree = tree.initializer();
assertThat(newClassTree.arguments()).isEmpty();
assertThat(newClassTree.classBody()).isNull();
assertThat(newClassTree.newKeyword()).isNull();
assertThatChildrenIteratorHasSize(newClassTree, 2);
tree = (EnumConstantTree) declarations.get(1);
assertThat(tree.is(Tree.Kind.ENUM_CONSTANT)).isTrue();
assertThat(tree.simpleName().name()).isEqualTo("C2");
assertThat(tree.separatorToken().text()).isEqualTo(";");
assertThatChildrenIteratorHasSize(tree, 3);
newClassTree = tree.initializer();
assertThat(newClassTree.arguments().openParenToken()).isNotNull();
assertThat(newClassTree.arguments()).hasSize(1);
assertThat(newClassTree.arguments().closeParenToken()).isNotNull();
assertThat(newClassTree.classBody()).isNotNull();
assertThat(newClassTree.classBody().openBraceToken().text()).isEqualTo("{");
assertThat(newClassTree.newKeyword()).isNull();
assertThatChildrenIteratorHasSize(newClassTree, 3);
}
@Test
public void enum_field() {
List<Tree> declarations = firstType("enum T { ; public int f1 = 42, f2[]; }").members();
assertThat(declarations).hasSize(3);
assertThat(declarations.get(0).is(Tree.Kind.EMPTY_STATEMENT)).isTrue();
VariableTree tree = (VariableTree) declarations.get(1);
assertThat(tree.is(Tree.Kind.VARIABLE)).isTrue();
assertThat(tree.modifiers().modifiers()).hasSize(1);
assertThat(tree.modifiers().modifiers().get(0).modifier()).isEqualTo(Modifier.PUBLIC);
assertThat(tree.type()).isInstanceOf(PrimitiveTypeTree.class);
assertThat(tree.simpleName().name()).isEqualTo("f1");
assertThat(tree.initializer()).isNotNull();
assertThatChildrenIteratorHasSize(tree, 6);
tree = (VariableTree) declarations.get(2);
assertThat(tree.is(Tree.Kind.VARIABLE)).isTrue();
assertThat(tree.modifiers().modifiers()).hasSize(1);
assertThat(tree.modifiers().modifiers().get(0).modifier()).isEqualTo(Modifier.PUBLIC);
assertThatArrayTypeHasBrackets((ArrayTypeTree) tree.type());
assertThat(tree.simpleName().name()).isEqualTo("f2");
assertThat(tree.initializer()).isNull();
assertThatChildrenIteratorHasSize(tree, 4);
}
@Test
public void enum_constructor() {
MethodTree tree = (MethodTree) firstType("enum T { ; T(int p1, int... p2) throws Exception1, Exception2 {} }").members().get(1);
assertThat(tree.is(Tree.Kind.CONSTRUCTOR)).isTrue();
assertThat(tree.returnType()).isNull();
assertThat(tree.simpleName().name()).isEqualTo("T");
assertThat(tree.parameters()).hasSize(2);
assertThat(tree.parameters().get(0).type()).isInstanceOf(PrimitiveTypeTree.class);
assertThatArrayTypeHasEllipsis((ArrayTypeTree) tree.parameters().get(1).type());
assertThat(tree.throwsClauses()).hasSize(2);
assertThat(tree.throwsClauses().separators()).hasSize(1);
assertThat(tree.block()).isNotNull();
assertThat(tree.defaultValue()).isNull();
assertThatChildrenIteratorHasSize(tree, 10);
}
@Test
public void enum_method() {
MethodTree tree = (MethodTree) firstType("enum T { ; int m(int p1, int... p2) throws Exception1, Exception2 {} }").members().get(1);
assertThat(tree.is(Tree.Kind.METHOD)).isTrue();
assertThat(tree.returnType()).isNotNull();
assertThat(tree.simpleName().name()).isEqualTo("m");
assertThat(tree.parameters()).hasSize(2);
assertThat(tree.parameters().get(0).type()).isInstanceOf(PrimitiveTypeTree.class);
assertThatArrayTypeHasEllipsis((ArrayTypeTree) tree.parameters().get(1).type());
assertThat(tree.throwsClauses()).hasSize(2);
assertThat(tree.throwsClauses().separators()).hasSize(1);
assertThat(tree.block()).isNotNull();
assertThat(tree.defaultValue()).isNull();
assertThatChildrenIteratorHasSize(tree, 11);
// void method
tree = (MethodTree) firstType("enum T { ; void m(int p) throws Exception1, Exception2; }").members().get(1);
assertThat(tree.is(Tree.Kind.METHOD)).isTrue();
assertThat(tree.returnType()).isNotNull();
assertThat(tree.simpleName().name()).isEqualTo("m");
assertThat(tree.parameters()).hasSize(1);
assertThat(tree.throwsClauses()).hasSize(2);
assertThat(tree.throwsClauses().separators()).hasSize(1);
assertThat(tree.block()).isNull();
assertThat(tree.defaultValue()).isNull();
assertThatChildrenIteratorHasSize(tree, 10);
}
/*
* 9. Interfaces
*/
@Test
public void interface_declaration() {
ClassTree tree = firstType("public interface T<U> extends I1, I2 { }");
assertThat(tree.is(Tree.Kind.INTERFACE)).isTrue();
assertThat(tree.modifiers().modifiers()).hasSize(1);
assertThat(tree.modifiers().modifiers().get(0).modifier()).isEqualTo(Modifier.PUBLIC);
assertThat(tree.simpleName().name()).isEqualTo("T");
TypeParameters typeParameters = tree.typeParameters();
assertThatChildrenIteratorHasSize(typeParameters, 3);
assertThat(typeParameters).isNotEmpty();
assertThat(tree.superClass()).isNull();
assertThat(tree.superInterfaces()).hasSize(2);
assertThat(tree.superInterfaces().separators()).hasSize(1);
assertThat(tree.declarationKeyword().text()).isEqualTo("interface");
assertThatChildrenIteratorHasSize(tree, 8);
tree = firstType("public interface T { }");
assertThat(tree.is(Tree.Kind.INTERFACE)).isTrue();
assertThat(tree.modifiers().modifiers()).hasSize(1);
assertThat(tree.modifiers().modifiers().get(0).modifier()).isEqualTo(Modifier.PUBLIC);
assertThat(tree.simpleName().name()).isEqualTo("T");
assertThat(tree.typeParameters()).isEmpty();
assertThat(tree.superClass()).isNull();
assertThat(tree.openBraceToken().text()).isEqualTo("{");
assertThat(tree.closeBraceToken().text()).isEqualTo("}");
assertThat(tree.superInterfaces()).isEmpty();
assertThat(tree.declarationKeyword().text()).isEqualTo("interface");
assertThatChildrenIteratorHasSize(tree, 7);
}
@Test
public void interface_field() {
List<Tree> declarations = firstType("interface T { public int f1 = 42, f2[] = { 13 }; }").members();
assertThat(declarations).hasSize(2);
VariableTree tree = (VariableTree) declarations.get(0);
assertThat(tree.is(Tree.Kind.VARIABLE)).isTrue();
assertThat(tree.modifiers().modifiers()).hasSize(1);
assertThat(tree.modifiers().modifiers().get(0).modifier()).isEqualTo(Modifier.PUBLIC);
assertThat(tree.type()).isInstanceOf(PrimitiveTypeTree.class);
assertThat(tree.simpleName().name()).isEqualTo("f1");
assertThat(tree.initializer()).isNotNull();
assertThatChildrenIteratorHasSize(tree, 6);
tree = (VariableTree) declarations.get(1);
assertThat(tree.is(Tree.Kind.VARIABLE)).isTrue();
assertThat(tree.modifiers().modifiers()).hasSize(1);
assertThat(tree.modifiers().modifiers().get(0).modifier()).isEqualTo(Modifier.PUBLIC);
assertThat(tree.type()).isInstanceOf(ArrayTypeTree.class);
assertThatArrayTypeHasBrackets((ArrayTypeTree) tree.type());
assertThat(tree.simpleName().name()).isEqualTo("f2");
assertThat(tree.initializer()).isNotNull();
assertThatChildrenIteratorHasSize(tree, 6);
}
@Test
public void interface_method() {
MethodTree tree = (MethodTree) firstTypeMember("interface T { <T> int m(int p1, int... p2) throws Exception1, Exception2; }");
assertThat(tree.is(Tree.Kind.METHOD)).isTrue();
assertThat(tree.typeParameters()).isNotEmpty();
assertThat(tree.returnType()).isNotNull();
assertThat(tree.simpleName().name()).isEqualTo("m");
assertThat(tree.parameters()).hasSize(2);
assertThat(tree.parameters().get(0).type()).isInstanceOf(PrimitiveTypeTree.class);
assertThat(tree.parameters().get(1).type()).isInstanceOf(ArrayTypeTree.class);
assertThat(tree.throwsClauses()).hasSize(2);
assertThat(tree.throwsClauses().separators()).hasSize(1);
assertThat(tree.block()).isNull();
assertThat(tree.defaultValue()).isNull();
assertThatChildrenIteratorHasSize(tree, 11);
// void method
tree = (MethodTree) firstTypeMember("interface T { void m(int p) throws Exception1, Exception2; }");
assertThat(tree.is(Tree.Kind.METHOD)).isTrue();
assertThat(tree.typeParameters()).isEmpty();
assertThat(tree.returnType()).isNotNull();
assertThat(tree.simpleName().name()).isEqualTo("m");
assertThat(tree.parameters()).hasSize(1);
assertThat(tree.throwsClauses()).hasSize(2);
assertThat(tree.throwsClauses().separators()).hasSize(1);
assertThat(tree.block()).isNull();
assertThat(tree.defaultValue()).isNull();
assertThatChildrenIteratorHasSize(tree, 10);
}
/*
* 9.6. Annotation Types
*/
@Test
public void annotation_declaration() {
ClassTree tree = firstType("public @interface T { }");
assertThat(tree.is(Tree.Kind.ANNOTATION_TYPE)).isTrue();
assertThat(tree.modifiers().modifiers()).hasSize(1);
assertThat(tree.modifiers().modifiers().get(0).keyword().text()).isEqualTo("public");
assertThat(tree.simpleName().name()).isEqualTo("T");
assertThat(tree.superClass()).isNull();
assertThat(tree.openBraceToken().text()).isEqualTo("{");
assertThat(tree.closeBraceToken().text()).isEqualTo("}");
assertThat(tree.superInterfaces()).isEmpty();
assertThat(tree.declarationKeyword().text()).isEqualTo("interface");
assertThatChildrenIteratorHasSize(tree, 8);
}
@Test
public void annotation_method() {
MethodTree tree = (MethodTree) firstTypeMember("@interface T { int m() default 0; }");
assertThat(tree.is(Tree.Kind.METHOD)).isTrue();
assertThat(tree.returnType()).isNotNull();
assertThat(tree.simpleName().name()).isEqualTo("m");
assertThat(tree.parameters()).isEmpty();
assertThat(tree.throwsClauses()).isEmpty();
assertThat(tree.block()).isNull();
assertThat(tree.defaultValue()).isNotNull();
assertThatChildrenIteratorHasSize(tree, 9);
tree = (MethodTree) firstTypeMember("@interface plop{ public String method(); }");
assertThat(tree.modifiers().modifiers()).hasSize(1);
assertThat(tree.modifiers().modifiers().get(0).keyword().text()).isEqualTo("public");
assertThatChildrenIteratorHasSize(tree, 7);
}
@Test
public void annotation_constant() {
List<Tree> members = firstType("@interface T { int c1 = 1, c2[] = { 2 }; }").members();
assertThat(members).hasSize(2);
VariableTree tree = (VariableTree) members.get(0);
assertThat(tree.is(Tree.Kind.VARIABLE)).isTrue();
assertThat(tree.type()).isInstanceOf(PrimitiveTypeTree.class);
assertThat(tree.simpleName().name()).isEqualTo("c1");
assertThat(tree.initializer()).isNotNull();
assertThatChildrenIteratorHasSize(tree, 6); // 1+5, as empty modifiers are always included
tree = (VariableTree) members.get(1);
assertThat(tree.is(Tree.Kind.VARIABLE)).isTrue();
assertThat(tree.type()).isInstanceOf(ArrayTypeTree.class);
assertThatArrayTypeHasBrackets((ArrayTypeTree) tree.type());
assertThat(tree.simpleName().name()).isEqualTo("c2");
assertThat(tree.initializer()).isNotNull();
assertThatChildrenIteratorHasSize(tree, 6);
}
/*
* 14. Blocks and Statements
*/
/**
* 14.2. Blocks
*/
@Test
public void blocks() {
BlockTree tree = ((MethodTree) firstTypeMember("class T { void m() { ; ; } }")).block();
assertThat(tree.is(Tree.Kind.BLOCK)).isTrue();
assertThat(tree.openBraceToken().text()).isEqualTo("{");
assertThat(tree.body()).hasSize(2);
assertThat(tree.closeBraceToken().text()).isEqualTo("}");
assertThatChildrenIteratorHasSize(tree, 4);
}
/**
* 14.3. Local Class Declarations
*/
@Test
public void local_class_declaration() {
BlockTree block = ((MethodTree) firstTypeMember("class T { void m() { abstract class Local { } } }")).block();
ClassTree tree = (ClassTree) block.body().get(0);
assertThat(tree.is(Tree.Kind.CLASS)).isTrue();
assertThat(tree.simpleName().identifierToken().text()).isEqualTo("Local");
assertThat(tree.modifiers().modifiers()).hasSize(1);
assertThat(tree.modifiers().modifiers().get(0).modifier()).isEqualTo(Modifier.ABSTRACT);
assertThat(tree).isNotNull();
assertThatChildrenIteratorHasSize(tree, 7);
block = ((MethodTree) firstTypeMember("class T { void m() { static enum Local { ; } } }")).block();
tree = (ClassTree) block.body().get(0);
assertThat(tree.is(Tree.Kind.ENUM)).isTrue();
assertThat(tree.modifiers().modifiers()).hasSize(1);
assertThat(tree.modifiers().modifiers().get(0).modifier()).isEqualTo(Modifier.STATIC);
assertThat(tree).isNotNull();
assertThatChildrenIteratorHasSize(tree, 8);
}
/**
* 14.4. Local Variable Declaration Statements
*/
@Test
public void local_variable_declaration() {
BlockTree block = ((MethodTree) firstTypeMember("class T { void m() { int a = 42, b[]; final @Nullable int c = 42; } }")).block();
List<StatementTree> declarations = block.body();
assertThat(declarations).hasSize(3);
VariableTree tree = (VariableTree) declarations.get(0);
assertThat(tree.is(Tree.Kind.VARIABLE)).isTrue();
assertThat(tree.modifiers().modifiers()).isEmpty();
assertThat(tree.type()).isInstanceOf(PrimitiveTypeTree.class);
assertThat(tree.simpleName().name()).isEqualTo("a");
assertThat(tree.initializer()).isNotNull();
assertThat(tree.endToken()).isNotNull();
assertThat(tree.endToken().text()).isEqualTo(",");
assertThatChildrenIteratorHasSize(tree, 6);
tree = (VariableTree) declarations.get(1);
assertThat(tree.is(Tree.Kind.VARIABLE)).isTrue();
assertThat(tree.modifiers().modifiers()).isEmpty();
assertThat(tree.type()).isInstanceOf(ArrayTypeTree.class);
assertThatArrayTypeHasBrackets((ArrayTypeTree) tree.type());
assertThat(tree.simpleName().name()).isEqualTo("b");
assertThat(tree.initializer()).isNull();
assertThat(tree.endToken()).isNotNull();
assertThat(tree.endToken().text()).isEqualTo(";");
assertThatChildrenIteratorHasSize(tree, 4);
// TODO Test annotation
tree = (VariableTree) declarations.get(2);
assertThat(tree.is(Tree.Kind.VARIABLE)).isTrue();
assertThat(tree.modifiers().modifiers()).hasSize(1);
assertThat(tree.modifiers().modifiers().get(0).modifier()).isEqualTo(Modifier.FINAL);
assertThat(tree.type()).isInstanceOf(PrimitiveTypeTree.class);
assertThat(tree.simpleName().name()).isEqualTo("c");
assertThat(tree.initializer()).isNotNull();
assertThat(tree.endToken()).isNotNull();
assertThat(tree.endToken().text()).isEqualTo(";");
assertThatChildrenIteratorHasSize(tree, 6);
}
/**
* 14.6. The Empty Statement
*/
@Test
public void empty_statement() {
EmptyStatementTree tree = (EmptyStatementTree) firstMethodFirstStatement("class T { void m() { ; } }");
assertThat(tree.is(Tree.Kind.EMPTY_STATEMENT)).isTrue();
assertThat(tree.semicolonToken().text()).isEqualTo(";");
assertThatChildrenIteratorHasSize(tree, 1);
}
/**
* 14.7. Labeled Statements
*/
@Test
public void labeled_statement() {
LabeledStatementTree tree = (LabeledStatementTree) firstMethodFirstStatement("class T { void m() { label: ; } }");
assertThat(tree.is(Tree.Kind.LABELED_STATEMENT)).isTrue();
assertThat(tree.label().name()).isEqualTo("label");
assertThat(tree.statement()).isNotNull();
assertThat(tree.colonToken().text()).isEqualTo(":");
assertThatChildrenIteratorHasSize(tree, 3);
}
/**
* 14.8. Expression Statements
*/
@Test
public void expression_statement() {
ExpressionStatementTree tree = (ExpressionStatementTree) firstMethodFirstStatement("class T { void m() { i++; } }");
assertThat(tree.is(Tree.Kind.EXPRESSION_STATEMENT)).isTrue();
assertThat(tree.expression()).isNotNull();
assertThat(tree.semicolonToken().text()).isEqualTo(";");
assertThatChildrenIteratorHasSize(tree, 2);
}
/**
* 14.9. The if Statement
*/
@Test
public void if_statement() {
IfStatementTree tree = (IfStatementTree) firstMethodFirstStatement("class T { void m() { if (true) { } } }");
assertThat(tree.is(Tree.Kind.IF_STATEMENT)).isTrue();
assertThat(tree.ifKeyword().text()).isEqualTo("if");
assertThat(tree.openParenToken().text()).isEqualTo("(");
assertThat(tree.condition()).isNotNull();
assertThat(tree.closeParenToken().text()).isEqualTo(")");
assertThat(tree.thenStatement()).isNotNull();
assertThat(tree.elseKeyword()).isNull();
assertThat(tree.elseStatement()).isNull();
assertThatChildrenIteratorHasSize(tree, 5);
tree = (IfStatementTree) firstMethodFirstStatement("class T { void m() { if (true) { } else { } } }");
assertThat(tree.is(Tree.Kind.IF_STATEMENT)).isTrue();
assertThat(tree.ifKeyword().text()).isEqualTo("if");
assertThat(tree.openParenToken().text()).isEqualTo("(");
assertThat(tree.condition()).isNotNull();
assertThat(tree.closeParenToken().text()).isEqualTo(")");
assertThat(tree.thenStatement()).isNotNull();
assertThat(tree.elseKeyword().text()).isEqualTo("else");
assertThat(tree.elseStatement()).isNotNull();
assertThatChildrenIteratorHasSize(tree, 7);
}
/**
* 14.10. The assert Statement
*/
@Test
public void assert_statement() {
AssertStatementTree tree = (AssertStatementTree) firstMethodFirstStatement("class T { void m() { assert true; } }");
assertThat(tree.is(Tree.Kind.ASSERT_STATEMENT)).isTrue();
assertThat(tree.assertKeyword().text()).isEqualTo("assert");
assertThat(tree.condition()).isNotNull();
assertThat(tree.colonToken()).isNull();
assertThat(tree.detail()).isNull();
assertThat(tree.semicolonToken().text()).isEqualTo(";");
assertThatChildrenIteratorHasSize(tree, 3);
tree = (AssertStatementTree) firstMethodFirstStatement("class T { void m() { assert true : \"detail\"; } }");
assertThat(tree.is(Tree.Kind.ASSERT_STATEMENT)).isTrue();
assertThat(tree.assertKeyword().text()).isEqualTo("assert");
assertThat(tree.condition()).isNotNull();
assertThat(tree.colonToken().text()).isEqualTo(":");
assertThat(tree.detail()).isNotNull();
assertThat(tree.semicolonToken().text()).isEqualTo(";");
assertThatChildrenIteratorHasSize(tree, 5);
}
/**
* 14.11. The switch Statement
*/
@Test
public void switch_statement() {
SwitchStatementTree tree = (SwitchStatementTree) firstMethodFirstStatement("class T { void m() { switch (e) { case 1: case 2: ; default: ; } } }");
assertThat(tree.is(Tree.Kind.SWITCH_STATEMENT)).isTrue();
assertThat(tree.switchKeyword().text()).isEqualTo("switch");
assertThat(tree.openParenToken().text()).isEqualTo("(");
assertThat(tree.expression()).isNotNull();
assertThat(tree.closeParenToken().text()).isEqualTo(")");
assertThat(tree.cases()).hasSize(2);
assertThatChildrenIteratorHasSize(tree, 8);
CaseGroupTree c = tree.cases().get(0);
assertThat(c.is(Tree.Kind.CASE_GROUP)).isTrue();
assertThat(c.labels()).hasSize(2);
CaseLabelTree caseLabelTree = c.labels().get(0);
assertThat(caseLabelTree.is(Tree.Kind.CASE_LABEL)).isTrue();
assertThat(caseLabelTree.caseOrDefaultKeyword().text()).isEqualTo("case");
assertThat(caseLabelTree.expression()).isNotNull();
assertThat(caseLabelTree.colonToken().text()).isEqualTo(":");
assertThatChildrenIteratorHasSize(caseLabelTree, 3);
caseLabelTree = c.labels().get(1);
assertThat(caseLabelTree.is(Tree.Kind.CASE_LABEL)).isTrue();
assertThat(caseLabelTree.caseOrDefaultKeyword().text()).isEqualTo("case");
assertThat(caseLabelTree.expression()).isNotNull();
assertThat(caseLabelTree.colonToken().text()).isEqualTo(":");
assertThatChildrenIteratorHasSize(caseLabelTree, 3);
assertThat(c.body()).hasSize(1);
c = tree.cases().get(1);
assertThat(c.is(Tree.Kind.CASE_GROUP)).isTrue();
assertThat(c.labels()).hasSize(1);
caseLabelTree = c.labels().get(0);
assertThat(caseLabelTree.is(Tree.Kind.CASE_LABEL)).isTrue();
assertThat(caseLabelTree.caseOrDefaultKeyword().text()).isEqualTo("default");
assertThat(caseLabelTree.expression()).isNull();
assertThat(caseLabelTree.colonToken().text()).isEqualTo(":");
assertThatChildrenIteratorHasSize(caseLabelTree, 2);
assertThat(c.body()).hasSize(1);
tree = (SwitchStatementTree) firstMethodFirstStatement("class T { void m() { switch (e) { default: } } }");
assertThat(tree.cases()).hasSize(1);
assertThat(tree.cases().get(0).body()).isEmpty();
assertThatChildrenIteratorHasSize(tree, 7);
}
/**
* 14.12. The while Statement
*/
@Test
public void while_statement() {
WhileStatementTree tree = (WhileStatementTree) firstMethodFirstStatement("class T { void m() { while (true) ; } }");
assertThat(tree.is(Tree.Kind.WHILE_STATEMENT)).isTrue();
assertThat(tree.whileKeyword().text()).isEqualTo("while");
assertThat(tree.openParenToken().text()).isEqualTo("(");
assertThat(tree.condition()).isNotNull();
assertThat(tree.closeParenToken().text()).isEqualTo(")");
assertThat(tree.statement()).isNotNull();
assertThatChildrenIteratorHasSize(tree, 5);
}
/**
* 14.13. The do Statement
*/
@Test
public void do_statement() {
DoWhileStatementTree tree = (DoWhileStatementTree) firstMethodFirstStatement("class T { void m() { do ; while (true); } }");
assertThat(tree.is(Tree.Kind.DO_STATEMENT)).isTrue();
assertThat(tree.doKeyword().text()).isEqualTo("do");
assertThat(tree.statement()).isNotNull();
assertThat(tree.whileKeyword().text()).isEqualTo("while");
assertThat(tree.openParenToken().text()).isEqualTo("(");
assertThat(tree.condition()).isNotNull();
assertThat(tree.closeParenToken().text()).isEqualTo(")");
assertThat(tree.semicolonToken().text()).isEqualTo(";");
assertThatChildrenIteratorHasSize(tree, 7);
}
/**
* 14.14. The for Statement
*/
@Test
public void for_statement() {
ForStatementTree tree = (ForStatementTree) firstMethodFirstStatement("class T { void m() { for (int i = 0; i < 42; i ++) ; } }");
assertThat(tree.is(Tree.Kind.FOR_STATEMENT)).isTrue();
assertThat(tree.forKeyword().text()).isEqualTo("for");
assertThat(tree.openParenToken().text()).isEqualTo("(");
assertThat(tree.initializer()).hasSize(1);
assertThat(tree.initializer().get(0)).isInstanceOf(VariableTree.class);
assertThatChildrenIteratorHasSize(tree.initializer().get(0), 5);
assertThat(tree.firstSemicolonToken().text()).isEqualTo(";");
assertThat(tree.condition()).isNotNull();
assertThat(tree.secondSemicolonToken().text()).isEqualTo(";");
assertThat(tree.update()).isNotNull();
assertThat(tree.closeParenToken().text()).isEqualTo(")");
assertThat(tree.statement()).isNotNull();
assertThatChildrenIteratorHasSize(tree, 9);
tree = (ForStatementTree) firstMethodFirstStatement("class T { void m() { for (i = 0; i < 42; i ++) ; } }");
assertThat(tree.is(Tree.Kind.FOR_STATEMENT)).isTrue();
assertThat(tree.initializer()).hasSize(1);
assertThat(tree.initializer().get(0)).isInstanceOf(ExpressionStatementTree.class);
assertThat(tree.condition()).isNotNull();
assertThat(tree.update()).isNotNull();
assertThat(tree.statement()).isNotNull();
assertThatChildrenIteratorHasSize(tree, 9);
tree = (ForStatementTree) firstMethodFirstStatement("class T { void m() { for ( ; ; ) ; } }");
assertThat(tree.is(Tree.Kind.FOR_STATEMENT)).isTrue();
assertThat(tree.initializer()).isEmpty();
assertThat(tree.condition()).isNull();
assertThat(tree.update()).isEmpty();
assertThat(tree.statement()).isNotNull();
assertThatChildrenIteratorHasSize(tree, 8);
tree = (ForStatementTree) firstMethodFirstStatement("class T { void m() { for (i = 0, j = 1; i < 42; i++, j--) ; } }");
assertThat(tree.is(Tree.Kind.FOR_STATEMENT)).isTrue();
assertThat(tree.initializer()).hasSize(2);
assertThat(tree.initializer().separators()).hasSize(1);
assertThat(tree.condition()).isNotNull();
assertThat(tree.update()).hasSize(2);
assertThat(tree.update().separators()).hasSize(1);
assertThat(tree.statement()).isNotNull();
assertThatChildrenIteratorHasSize(tree, 9);
tree = (ForStatementTree) firstMethodFirstStatement("class T { void m() { for (int i = 0, j = 1; i < 42; i++, j--) ; } }");
assertThat(tree.is(Tree.Kind.FOR_STATEMENT)).isTrue();
assertThat(tree.initializer()).hasSize(2);
assertThat(tree.initializer().separators()).hasSize(0);
assertThat(tree.condition()).isNotNull();
assertThat(tree.update()).hasSize(2);
assertThat(tree.update().separators()).hasSize(1);
assertThat(tree.statement()).isNotNull();
assertThatChildrenIteratorHasSize(tree, 9);
}
@Test
public void enhanced_for_statement() {
ForEachStatement tree = (ForEachStatement) firstMethodFirstStatement("class T { void m() { for (Object o : objects) ; } }");
assertThat(tree.is(Tree.Kind.FOR_EACH_STATEMENT)).isTrue();
assertThat(tree.forKeyword().text()).isEqualTo("for");
assertThat(tree.openParenToken().text()).isEqualTo("(");
assertThat(tree.variable()).isNotNull();
assertThat(tree.colonToken().text()).isEqualTo(":");
assertThat(tree.expression()).isNotNull();
assertThat(tree.closeParenToken().text()).isEqualTo(")");
assertThat(tree.statement()).isNotNull();
assertThatChildrenIteratorHasSize(tree, 7);
}
/**
* 14.15. The break Statement
*/
@Test
public void break_statement() {
BreakStatementTree tree = (BreakStatementTree) firstMethodFirstStatement("class T { void m() { break ; } }");
assertThat(tree.is(Tree.Kind.BREAK_STATEMENT)).isTrue();
assertThat(tree.breakKeyword().text()).isEqualTo("break");
assertThat(tree.label()).isNull();
assertThat(tree.semicolonToken().text()).isEqualTo(";");
assertThatChildrenIteratorHasSize(tree, 2);
tree = (BreakStatementTree) firstMethodFirstStatement("class T { void m() { break label ; } }");
assertThat(tree.is(Tree.Kind.BREAK_STATEMENT)).isTrue();
assertThat(tree.breakKeyword().text()).isEqualTo("break");
assertThat(tree.label().name()).isEqualTo("label");
assertThat(tree.semicolonToken().text()).isEqualTo(";");
assertThatChildrenIteratorHasSize(tree, 3);
}
/**
* 14.16. The continue Statement
*/
@Test
public void continue_statement() {
ContinueStatementTree tree = (ContinueStatementTree) firstMethodFirstStatement("class T { void m() { continue ; } }");
assertThat(tree.is(Tree.Kind.CONTINUE_STATEMENT)).isTrue();
assertThat(tree.continueKeyword().text()).isEqualTo("continue");
assertThat(tree.label()).isNull();
assertThat(tree.semicolonToken().text()).isEqualTo(";");
assertThatChildrenIteratorHasSize(tree, 2);
tree = (ContinueStatementTree) firstMethodFirstStatement("class T { void m() { continue label ; } }");
assertThat(tree.is(Tree.Kind.CONTINUE_STATEMENT)).isTrue();
assertThat(tree.continueKeyword().text()).isEqualTo("continue");
assertThat(tree.label().name()).isEqualTo("label");
assertThat(tree.semicolonToken().text()).isEqualTo(";");
assertThatChildrenIteratorHasSize(tree, 3);
}
/**
* 14.17. The return Statement
*/
@Test
public void return_statement() {
ReturnStatementTree tree = (ReturnStatementTree) firstMethodFirstStatement("class T { boolean m() { return ; } }");
assertThat(tree.is(Tree.Kind.RETURN_STATEMENT)).isTrue();
assertThat(tree.returnKeyword().text()).isEqualTo("return");
assertThat(tree.expression()).isNull();
assertThat(tree.semicolonToken().text()).isEqualTo(";");
assertThatChildrenIteratorHasSize(tree, 2);
tree = (ReturnStatementTree) firstMethodFirstStatement("class T { boolean m() { return true; } }");
assertThat(tree.is(Tree.Kind.RETURN_STATEMENT)).isTrue();
assertThat(tree.returnKeyword().text()).isEqualTo("return");
assertThat(tree.expression()).isNotNull();
assertThat(tree.semicolonToken().text()).isEqualTo(";");
assertThatChildrenIteratorHasSize(tree, 3);
}
/**
* 14.18. The throw Statement
*/
@Test
public void throw_statement() {
ThrowStatementTree tree = (ThrowStatementTree) firstMethodFirstStatement("class T { void m() { throw e; } }");
assertThat(tree.is(Tree.Kind.THROW_STATEMENT)).isTrue();
assertThat(tree.throwKeyword().text()).isEqualTo("throw");
assertThat(tree.expression()).isNotNull();
assertThat(tree.semicolonToken().text()).isEqualTo(";");
assertThatChildrenIteratorHasSize(tree, 3);
}
/**
* 14.19. The synchronized Statement
*/
@Test
public void synchronized_statement() {
SynchronizedStatementTree tree = (SynchronizedStatementTree) firstMethodFirstStatement("class T { void m() { synchronized(e) { } } }");
assertThat(tree.is(Tree.Kind.SYNCHRONIZED_STATEMENT)).isTrue();
assertThat(tree.synchronizedKeyword().text()).isEqualTo("synchronized");
assertThat(tree.openParenToken().text()).isEqualTo("(");
assertThat(tree.expression()).isNotNull();
assertThat(tree.closeParenToken().text()).isEqualTo(")");
assertThat(tree.block()).isNotNull();
assertThatChildrenIteratorHasSize(tree, 5);
}
/**
* 14.20. The try statement
*/
@Test
public void try_statement() {
TryStatementTree tree = (TryStatementTree) firstMethodFirstStatement("class T { void m() { try { } finally { } } }");
assertThat(tree.is(Tree.Kind.TRY_STATEMENT)).isTrue();
assertThat(tree.resources()).isEmpty();
assertThat(tree.block()).isNotNull();
assertThat(tree.catches()).isEmpty();
assertThat(tree.finallyKeyword().text()).isEqualTo("finally");
assertThat(tree.finallyBlock()).isNotNull();
assertThatChildrenIteratorHasSize(tree, 4);
tree = (TryStatementTree) firstMethodFirstStatement("class T { void m() { try { } catch (RuntimeException e1) { } catch (Exception e2) { } } }");
assertThat(tree.is(Tree.Kind.TRY_STATEMENT)).isTrue();
assertThat(tree.tryKeyword().text()).isEqualTo("try");
assertThat(tree.openParenToken()).isNull();
assertThat(tree.resources()).isEmpty();
assertThat(tree.closeParenToken()).isNull();
assertThat(tree.block()).isNotNull();
assertThat(tree.finallyKeyword()).isNull();
assertThat(tree.finallyBlock()).isNull();
assertThat(tree.catches()).hasSize(2);
assertThatChildrenIteratorHasSize(tree, 4);
CatchTree catchTree = tree.catches().get(0);
assertThat(catchTree.catchKeyword().text()).isEqualTo("catch");
assertThat(catchTree.block()).isNotNull();
assertThat(catchTree.openParenToken().text()).isEqualTo("(");
assertThat(catchTree.closeParenToken().text()).isEqualTo(")");
assertThatChildrenIteratorHasSize(catchTree, 5);
VariableTree parameterTree = catchTree.parameter();
assertThat(parameterTree.type()).isNotNull();
assertThat(parameterTree.simpleName().name()).isEqualTo("e1");
assertThat(parameterTree.initializer()).isNull();
assertThatChildrenIteratorHasSize(parameterTree, 3);
catchTree = tree.catches().get(1);
assertThatChildrenIteratorHasSize(catchTree, 5);
parameterTree = catchTree.parameter();
assertThat(parameterTree.type()).isNotNull();
assertThat(parameterTree.simpleName().name()).isEqualTo("e2");
assertThat(parameterTree.initializer()).isNull();
assertThatChildrenIteratorHasSize(parameterTree, 3);
tree = (TryStatementTree) firstMethodFirstStatement("class T { void m() { try { } catch (Exception e) { } finally { } } }");
assertThat(tree.is(Tree.Kind.TRY_STATEMENT)).isTrue();
assertThat(tree.resources()).isEmpty();
assertThat(tree.block()).isNotNull();
assertThat(tree.catches()).hasSize(1);
assertThat(tree.finallyKeyword().text()).isEqualTo("finally");
assertThatChildrenIteratorHasSize(tree.catches().get(0), 5);
assertThat(tree.finallyBlock()).isNotNull();
assertThatChildrenIteratorHasSize(tree, 5);
tree = (TryStatementTree) firstMethodFirstStatement("class T { void m() { try { } catch (final @Foo Exception e) { } } }");
assertThat(tree.is(Tree.Kind.TRY_STATEMENT)).isTrue();
assertThat(tree.resources()).isEmpty();
assertThat(tree.block()).isNotNull();
assertThat(tree.catches()).hasSize(1);
assertThat(tree.finallyKeyword()).isNull();
assertThat(tree.finallyBlock()).isNull();
assertThatChildrenIteratorHasSize(tree, 3);
catchTree = tree.catches().get(0);
assertThatChildrenIteratorHasSize(catchTree, 5);
parameterTree = catchTree.parameter();
assertThat(parameterTree.modifiers()).hasSize(2);
assertThat(parameterTree.simpleName().identifierToken().text()).isEqualTo("e");
assertThat(parameterTree.type().is(Tree.Kind.IDENTIFIER)).isTrue();
assertThat(parameterTree.endToken()).isNull();
assertThat(parameterTree.initializer()).isNull();
assertThatChildrenIteratorHasSize(parameterTree, 3);
tree = (TryStatementTree) firstMethodFirstStatement("class T { void m() { try (final @Foo Resource r = open()) { } } }");
assertThat(tree.is(Tree.Kind.TRY_STATEMENT)).isTrue();
assertThat(tree.block()).isNotNull();
assertThat(tree.catches()).isEmpty();
assertThat(tree.finallyKeyword()).isNull();
assertThat(tree.finallyBlock()).isNull();
assertThat(tree.openParenToken().text()).isEqualTo("(");
assertThat(tree.resources()).hasSize(1);
assertThat(tree.closeParenToken().text()).isEqualTo(")");
assertThatChildrenIteratorHasSize(tree, 5);
VariableTree resource = tree.resources().get(0);
assertThat(resource.simpleName().name()).isEqualTo("r");
assertThat(resource.initializer()).isNotNull();
assertThat(resource.modifiers()).hasSize(2);
tree = (TryStatementTree) firstMethodFirstStatement("class T { void m() { try (Resource r1 = open(); Resource r2 = open()) { } catch (Exception e) { } finally { } } }");
assertThat(tree.is(Tree.Kind.TRY_STATEMENT)).isTrue();
assertThat(tree.block()).isNotNull();
assertThat(tree.catches()).hasSize(1);
assertThat(tree.finallyKeyword().text()).isEqualTo("finally");
assertThatChildrenIteratorHasSize(tree.catches().get(0), 5);
assertThat(tree.finallyBlock()).isNotNull();
assertThat(tree.openParenToken().text()).isEqualTo("(");
assertThat(tree.resources()).hasSize(2);
assertThat(tree.resources().separators()).hasSize(1);
assertThat(tree.closeParenToken().text()).isEqualTo(")");
resource = tree.resources().get(0);
assertThat(resource.simpleName().name()).isEqualTo("r1");
assertThat(resource.initializer()).isNotNull();
resource = tree.resources().get(1);
assertThat(resource.simpleName().name()).isEqualTo("r2");
assertThat(resource.initializer()).isNotNull();
assertThatChildrenIteratorHasSize(tree, 8);
tree = (TryStatementTree) firstMethodFirstStatement("class T { void m() { try { } catch (Exception1 | Exception2 e) { } } }");
parameterTree = tree.catches().get(0).parameter();
assertThatChildrenIteratorHasSize(parameterTree, 3);
UnionTypeTree type = (UnionTypeTree) parameterTree.type();
assertThatChildrenIteratorHasSize(type, 1);
assertThat(type.typeAlternatives()).hasSize(2);
assertThat(type.typeAlternatives().separators()).hasSize(1);
assertThatChildrenIteratorHasSize(tree, 3);
}
/*
* 15. Expressions
*/
/*
* 15.8. Primary Expressions
*/
/**
* 15.8.2. Class Literals
*/
@Test
public void class_literal() {
MemberSelectExpressionTree tree = (MemberSelectExpressionTree) expressionOfReturnStatement("class T { m() { return void.class; } }");
assertThat(tree.is(Tree.Kind.MEMBER_SELECT)).isTrue();
assertThat(tree.expression()).isNotNull();
assertThat(tree.identifier().identifierToken().text()).isEqualTo("class");
assertThat(tree.identifier().name()).isEqualTo("class");
assertThat(tree.operatorToken()).isNotNull();
assertThatChildrenIteratorHasSize(tree, 3);
tree = (MemberSelectExpressionTree) expressionOfReturnStatement("class T { m() { return int.class; } }");
assertThat(tree.is(Tree.Kind.MEMBER_SELECT)).isTrue();
assertThat(tree.expression()).isInstanceOf(PrimitiveTypeTree.class);
assertThat(tree.identifier().identifierToken().text()).isEqualTo("class");
assertThat(tree.identifier().name()).isEqualTo("class");
assertThat(tree.operatorToken()).isNotNull();
assertThatChildrenIteratorHasSize(tree, 3);
tree = (MemberSelectExpressionTree) expressionOfReturnStatement("class T { m() { return int[].class; } }");
assertThat(tree.is(Tree.Kind.MEMBER_SELECT)).isTrue();
assertThat(tree.expression()).isInstanceOf(ArrayTypeTree.class);
assertThatArrayTypeHasBrackets((ArrayTypeTree) tree.expression());
assertThat(tree.identifier().identifierToken().text()).isEqualTo("class");
assertThat(tree.identifier().name()).isEqualTo("class");
assertThat(tree.operatorToken()).isNotNull();
assertThatChildrenIteratorHasSize(tree, 3);
tree = (MemberSelectExpressionTree) expressionOfReturnStatement("class T { m() { return T.class; } }");
assertThat(tree.is(Tree.Kind.MEMBER_SELECT)).isTrue();
assertThat(tree.expression()).isNotNull();
assertThat(tree.identifier().identifierToken().text()).isEqualTo("class");
assertThat(tree.identifier().name()).isEqualTo("class");
assertThat(tree.operatorToken()).isNotNull();
assertThatChildrenIteratorHasSize(tree, 3);
tree = (MemberSelectExpressionTree) expressionOfReturnStatement("class T { m() { return T[].class; } }");
assertThat(tree.is(Tree.Kind.MEMBER_SELECT)).isTrue();
assertThat(tree.expression()).isInstanceOf(ArrayTypeTree.class);
assertThatArrayTypeHasBrackets((ArrayTypeTree) tree.expression());
assertThat(tree.identifier().identifierToken().text()).isEqualTo("class");
assertThat(tree.identifier().name()).isEqualTo("class");
assertThat(tree.operatorToken()).isNotNull();
assertThatChildrenIteratorHasSize(tree, 3);
}
/**
* 15.8.3. this
*/
@Test
public void this_expression() {
IdentifierTree tree = (IdentifierTree) expressionOfReturnStatement("class T { Object m() { return this; } }");
assertThat(tree.is(Tree.Kind.IDENTIFIER)).isTrue();
assertThat(tree).isNotNull();
assertThat(tree.identifierToken().text()).isEqualTo("this");
assertThat(tree.name()).isEqualTo("this");
assertThatChildrenIteratorHasSize(tree, 1);
}
/**
* 15.8.4. Qualified this
*/
@Test
public void qualified_this() {
MemberSelectExpressionTree tree = (MemberSelectExpressionTree) expressionOfReturnStatement("class T { Object m() { return ClassName.this; } }");
assertThat(tree.is(Tree.Kind.MEMBER_SELECT)).isTrue();
assertThat(tree.expression()).isNotNull();
assertThat(tree.identifier().identifierToken().text()).isEqualTo("this");
assertThat(tree.identifier().name()).isEqualTo("this");
assertThatChildrenIteratorHasSize(tree, 3);
}
/**
* 15.8.5. Parenthesized Expressions
*/
@Test
public void parenthesized_expression() {
ParenthesizedTree tree = (ParenthesizedTree) expressionOfReturnStatement("class T { boolean m() { return (true); } }");
assertThat(tree.is(Tree.Kind.PARENTHESIZED_EXPRESSION)).isTrue();
assertThat(tree.openParenToken().text()).isEqualTo("(");
assertThat(tree.expression()).isNotNull();
assertThat(tree.closeParenToken().text()).isEqualTo(")");
assertThatChildrenIteratorHasSize(tree, 3);
}
/**
* 15.9. Class Instance Creation Expressions
*/
@Test
public void class_instance_creation_expression() {
NewClassTree tree = (NewClassTree) expressionOfReturnStatement("class T { T m() { return new T(true, false) {}; } }");
assertThat(tree.is(Tree.Kind.NEW_CLASS)).isTrue();
assertThat(tree.enclosingExpression()).isNull();
assertThat(tree.dotToken()).isNull();
assertThat(tree.arguments().openParenToken()).isNotNull();
assertThat(tree.arguments()).hasSize(2);
assertThat(tree.arguments().closeParenToken()).isNotNull();
assertThat(tree.identifier()).isNotNull();
assertThat(tree.classBody()).isNotNull();
assertThat(tree.newKeyword()).isNotNull();
assertThatChildrenIteratorHasSize(tree, 4);
// assertThat(tree.typeArguments()).isEmpty();
tree = (NewClassTree) expressionOfReturnStatement("class T { T m() { return Enclosing.new T(true, false) {}; } }");
assertThat(tree.is(Tree.Kind.NEW_CLASS)).isTrue();
assertThat(tree.enclosingExpression()).isNotNull();
assertThat(tree.dotToken()).isNotNull();
assertThat(tree.identifier()).isNotNull();
assertThat(tree.arguments().openParenToken()).isNotNull();
assertThat(tree.arguments()).hasSize(2);
assertThat(tree.arguments().closeParenToken()).isNotNull();
assertThat(tree.classBody()).isNotNull();
assertThat(tree.newKeyword()).isNotNull();
assertThatChildrenIteratorHasSize(tree, 6);
// assertThat(tree.typeArguments()).isEmpty();
tree = (NewClassTree) expressionOfReturnStatement("class T { T m() { return this.new T(true, false) {}; } }");
assertThat(tree.enclosingExpression()).isNotNull();
assertThat(tree.dotToken()).isNotNull();
assertThat(tree.identifier()).isNotNull();
assertThat(tree.arguments().openParenToken()).isNotNull();
assertThat(tree.arguments()).hasSize(2);
assertThat(tree.arguments().closeParenToken()).isNotNull();
assertThat(tree.classBody()).isNotNull();
assertThat(tree.newKeyword()).isNotNull();
assertThatChildrenIteratorHasSize(tree, 6);
// assertThat(tree.typeArguments()).isEmpty();
tree = (NewClassTree) ((VariableTree) firstMethodFirstStatement("class T { void m() { Foo myInt = new<Integer>Foo(42); } }")).initializer();
assertThat(tree.enclosingExpression()).isNull();
assertThat(tree.dotToken()).isNull();
assertThat(tree.identifier()).isNotNull();
assertThat(tree.typeArguments()).isNotNull();
assertThat(tree.typeArguments()).hasSize(1);
assertThatChildrenIteratorHasSize(tree, 4);
}
/**
* 15.10. Array Creation Expressions
*/
@Test
public void array_creation_expression() {
NewArrayTree tree = (NewArrayTree) expressionOfReturnStatement("class T { int[][] m() { return new int[][]{{1}, {2, 3}}; } }");
assertThat(tree.is(Tree.Kind.NEW_ARRAY)).isTrue();
assertThat(tree.type()).isNotNull();
assertThat(tree.dimensions()).hasSize(2);
assertThat(tree.initializers()).hasSize(2);
assertThat(tree.initializers().separators()).hasSize(1);
assertThat(tree.newKeyword()).isNotNull();
assertThatChildrenIteratorHasSize(tree, 7);
ArrayDimensionTree dimension = tree.dimensions().get(0);
assertThat(dimension.is(Tree.Kind.ARRAY_DIMENSION)).isTrue();
assertThat(dimension.annotations()).isEmpty();
assertThat(dimension.openBracketToken().text()).isEqualTo("[");
assertThat(dimension.expression()).isNull();
assertThat(dimension.closeBracketToken().text()).isEqualTo("]");
assertThatChildrenIteratorHasSize(dimension, 2);
dimension = tree.dimensions().get(1);
assertThat(dimension.is(Tree.Kind.ARRAY_DIMENSION)).isTrue();
assertThat(dimension.annotations()).isEmpty();
assertThat(dimension.openBracketToken().text()).isEqualTo("[");
assertThat(dimension.expression()).isNull();
assertThat(dimension.closeBracketToken().text()).isEqualTo("]");
assertThatChildrenIteratorHasSize(dimension, 2);
NewArrayTree firstDim = (NewArrayTree) tree.initializers().get(0);
assertThat(firstDim.initializers()).hasSize(1);
assertThat(firstDim.initializers().separators()).isEmpty();
assertThatChildrenIteratorHasSize(firstDim, 3);
NewArrayTree secondDim = (NewArrayTree) tree.initializers().get(1);
assertThat(secondDim.initializers()).hasSize(2);
assertThat(secondDim.initializers().separators()).hasSize(1);
assertThatChildrenIteratorHasSize(secondDim, 3);
tree = (NewArrayTree) expressionOfReturnStatement("class T { int[][] m() { return new int[2][2]; } }");
assertThat(tree.is(Tree.Kind.NEW_ARRAY)).isTrue();
assertThat(tree.type()).isNotNull();
assertThat(tree.dimensions()).hasSize(2);
assertThat(tree.initializers()).isEmpty();
assertThat(tree.newKeyword()).isNotNull();
assertThatChildrenIteratorHasSize(tree, 5);
dimension = tree.dimensions().get(0);
assertThat(dimension.is(Tree.Kind.ARRAY_DIMENSION)).isTrue();
assertThat(dimension.annotations()).isEmpty();
assertThat(dimension.openBracketToken().text()).isEqualTo("[");
assertThat(dimension.expression().is(Tree.Kind.INT_LITERAL)).isTrue();
assertThat(dimension.closeBracketToken().text()).isEqualTo("]");
assertThatChildrenIteratorHasSize(dimension, 3);
tree = (NewArrayTree) expressionOfReturnStatement("class T { int[][] m() { return new int[] @Bar [] {{}, {}}; } }");
assertThat(tree.is(Tree.Kind.NEW_ARRAY)).isTrue();
assertThat(tree.type()).isNotNull();
assertThat(tree.dimensions()).hasSize(2);
assertThat(tree.initializers()).hasSize(2);
assertThat(tree.newKeyword()).isNotNull();
assertThatChildrenIteratorHasSize(tree, 7);
dimension = tree.dimensions().get(0);
assertThat(dimension.is(Tree.Kind.ARRAY_DIMENSION)).isTrue();
assertThat(dimension.annotations()).isEmpty();
assertThat(dimension.openBracketToken().text()).isEqualTo("[");
assertThat(dimension.expression()).isNull();
assertThat(dimension.closeBracketToken().text()).isEqualTo("]");
assertThatChildrenIteratorHasSize(dimension, 2);
dimension = tree.dimensions().get(1);
assertThat(dimension.is(Tree.Kind.ARRAY_DIMENSION)).isTrue();
assertThat(dimension.annotations()).hasSize(1);
assertThat(dimension.openBracketToken().text()).isEqualTo("[");
assertThat(dimension.expression()).isNull();
assertThat(dimension.closeBracketToken().text()).isEqualTo("]");
assertThatChildrenIteratorHasSize(dimension, 3);
tree = (NewArrayTree) expressionOfReturnStatement("class T { int[][] m() { return new int[2] @Bar []; } }");
assertThat(tree.is(Tree.Kind.NEW_ARRAY)).isTrue();
assertThat(tree.type()).isNotNull();
assertThat(tree.dimensions()).hasSize(2);
assertThat(tree.initializers()).isEmpty();
assertThat(tree.newKeyword()).isNotNull();
assertThatChildrenIteratorHasSize(tree, 5);
dimension = tree.dimensions().get(0);
assertThat(dimension.is(Tree.Kind.ARRAY_DIMENSION)).isTrue();
assertThat(dimension.annotations()).isEmpty();
assertThat(dimension.openBracketToken().text()).isEqualTo("[");
assertThat(dimension.expression().is(Tree.Kind.INT_LITERAL)).isTrue();
assertThat(dimension.closeBracketToken().text()).isEqualTo("]");
assertThatChildrenIteratorHasSize(dimension, 3);
dimension = tree.dimensions().get(1);
assertThat(dimension.is(Tree.Kind.ARRAY_DIMENSION)).isTrue();
assertThat(dimension.annotations()).hasSize(1);
assertThat(dimension.openBracketToken().text()).isEqualTo("[");
assertThat(dimension.expression()).isNull();
assertThat(dimension.closeBracketToken().text()).isEqualTo("]");
assertThatChildrenIteratorHasSize(dimension, 3);
tree = (NewArrayTree) expressionOfReturnStatement("class T { int[] m() { return new int @Foo [2]; } }");
assertThat(tree.is(Tree.Kind.NEW_ARRAY)).isTrue();
assertThat(tree.type()).isNotNull();
assertThat(tree.dimensions()).hasSize(1);
assertThat(tree.initializers()).isEmpty();
assertThat(tree.newKeyword()).isNotNull();
assertThatChildrenIteratorHasSize(tree, 4);
dimension = tree.dimensions().get(0);
assertThat(dimension.is(Tree.Kind.ARRAY_DIMENSION)).isTrue();
assertThat(dimension.annotations()).hasSize(1);
assertThat(dimension.openBracketToken().text()).isEqualTo("[");
assertThat(dimension.expression().is(Tree.Kind.INT_LITERAL)).isTrue();
assertThat(dimension.closeBracketToken().text()).isEqualTo("]");
assertThatChildrenIteratorHasSize(dimension, 4);
tree = (NewArrayTree) ((VariableTree) firstMethodFirstStatement("class T { void m() { int[] a = {,}; } }")).initializer();
assertThat(tree.is(Tree.Kind.NEW_ARRAY)).isTrue();
assertThat(tree.type()).isNull();
assertThat(tree.dimensions()).isEmpty();
assertThat(tree.initializers()).isEmpty();
assertThat(tree.initializers().separators()).hasSize(1);
}
/**
* 15.11. Field Access Expressions
*/
@Test
public void field_access_expression() {
MemberSelectExpressionTree tree;
tree = (MemberSelectExpressionTree) expressionOfReturnStatement("class T { int m() { return super.identifier; } }");
assertThat(tree.is(Tree.Kind.MEMBER_SELECT)).isTrue();
assertThat(tree.expression()).isNotNull();
assertThat(tree.identifier()).isNotNull();
assertThat(tree.operatorToken()).isNotNull();
assertThatChildrenIteratorHasSize(tree, 3);
tree = (MemberSelectExpressionTree) expressionOfReturnStatement("class T { int m() { return ClassName.super.identifier; } }");
assertThat(tree.is(Tree.Kind.MEMBER_SELECT)).isTrue();
assertThat(tree.expression()).isNotNull();
assertThat(tree.identifier()).isNotNull();
assertThat(tree.operatorToken()).isNotNull();
assertThatChildrenIteratorHasSize(tree, 3);
}
/**
* 15.12. Method Invocation Expressions
*/
@Test
public void method_invocation_expression() {
// TODO test NonWildTypeArguments
MethodInvocationTree tree = (MethodInvocationTree) expressionOfFirstStatement("class T { void m() { identifier(true, false); } }");
assertThat(tree.is(Tree.Kind.METHOD_INVOCATION)).isTrue();
assertThat(((IdentifierTree) tree.methodSelect()).name()).isEqualTo("identifier");
assertThat(tree.arguments().openParenToken()).isNotNull();
assertThat(tree.arguments()).hasSize(2);
assertThat(tree.arguments().separators()).hasSize(1);
assertThat(tree.arguments().closeParenToken()).isNotNull();
assertThatChildrenIteratorHasSize(tree, 2);
tree = (MethodInvocationTree) expressionOfFirstStatement("class T { void m() { <T>identifier(true, false); } }");
assertThat(tree.is(Tree.Kind.METHOD_INVOCATION)).isTrue();
assertThat(((IdentifierTree) tree.methodSelect()).name()).isEqualTo("identifier");
assertThat(tree.arguments()).hasSize(2);
assertThatChildrenIteratorHasSize(tree, 3);
tree = (MethodInvocationTree) expressionOfFirstStatement("class T { T() { super.identifier(true, false); } }");
assertThat(tree.is(Tree.Kind.METHOD_INVOCATION)).isTrue();
MemberSelectExpressionTree memberSelectExpression = (MemberSelectExpressionTree) tree.methodSelect();
assertThatChildrenIteratorHasSize(memberSelectExpression, 3);
assertThat(memberSelectExpression.identifier().name()).isEqualTo("identifier");
assertThat(memberSelectExpression.operatorToken()).isNotNull();
assertThat(((IdentifierTree) memberSelectExpression.expression()).name()).isEqualTo("super");
assertThat(tree.arguments()).hasSize(2);
assertThatChildrenIteratorHasSize(tree, 2);
tree = (MethodInvocationTree) expressionOfFirstStatement("class T { T() { TypeName.super.identifier(true, false); } }");
assertThat(tree.is(Tree.Kind.METHOD_INVOCATION)).isTrue();
memberSelectExpression = (MemberSelectExpressionTree) tree.methodSelect();
assertThat(memberSelectExpression.identifier().name()).isEqualTo("identifier");
assertThat(memberSelectExpression.operatorToken()).isNotNull();
memberSelectExpression = (MemberSelectExpressionTree) memberSelectExpression.expression();
assertThatChildrenIteratorHasSize(memberSelectExpression, 3);
assertThat(memberSelectExpression.identifier().name()).isEqualTo("super");
assertThat(memberSelectExpression.operatorToken()).isNotNull();
assertThat(((IdentifierTree) memberSelectExpression.expression()).name()).isEqualTo("TypeName");
assertThat(tree.arguments()).hasSize(2);
assertThatChildrenIteratorHasSize(tree, 2);
tree = (MethodInvocationTree) expressionOfFirstStatement("class T { T() { TypeName.identifier(true, false); } }");
assertThat(tree.is(Tree.Kind.METHOD_INVOCATION)).isTrue();
memberSelectExpression = (MemberSelectExpressionTree) tree.methodSelect();
assertThatChildrenIteratorHasSize(memberSelectExpression, 3);
assertThat(memberSelectExpression.identifier().name()).isEqualTo("identifier");
assertThat(memberSelectExpression.operatorToken()).isNotNull();
assertThat(((IdentifierTree) memberSelectExpression.expression()).name()).isEqualTo("TypeName");
assertThat(tree.arguments()).hasSize(2);
assertThatChildrenIteratorHasSize(tree, 2);
tree = (MethodInvocationTree) expressionOfFirstStatement("class T { T() { TypeName.<T>identifier(true, false); } }");
assertThat(tree.is(Tree.Kind.METHOD_INVOCATION)).isTrue();
memberSelectExpression = (MemberSelectExpressionTree) tree.methodSelect();
assertThatChildrenIteratorHasSize(memberSelectExpression, 3);
assertThat(memberSelectExpression.identifier().name()).isEqualTo("identifier");
assertThat(memberSelectExpression.operatorToken()).isNotNull();
assertThat(((IdentifierTree) memberSelectExpression.expression()).name()).isEqualTo("TypeName");
assertThat(tree.arguments()).hasSize(2);
assertThatChildrenIteratorHasSize(tree, 3);
tree = (MethodInvocationTree) expressionOfFirstStatement("class T { T() { primary().<T>identifier(true, false); } }");
assertThat(tree.is(Tree.Kind.METHOD_INVOCATION)).isTrue();
memberSelectExpression = (MemberSelectExpressionTree) tree.methodSelect();
assertThatChildrenIteratorHasSize(memberSelectExpression, 3);
assertThat(memberSelectExpression.identifier().name()).isEqualTo("identifier");
assertThat(memberSelectExpression.expression()).isInstanceOf(MethodInvocationTree.class);
assertThat(memberSelectExpression.operatorToken()).isNotNull();
assertThat(tree.arguments()).hasSize(2);
assertThatChildrenIteratorHasSize(tree, 3);
}
/**
* 8.8.7.1. Explicit Constructor Invocations
*/
@Test
public void explicit_constructor_invocation() {
// TODO test NonWildTypeArguments
MethodInvocationTree tree = (MethodInvocationTree) expressionOfFirstStatement("class T { T() { this(true, false); } }");
assertThat(tree.is(Tree.Kind.METHOD_INVOCATION)).isTrue();
assertThat(((IdentifierTree) tree.methodSelect()).name()).isEqualTo("this");
assertThat(tree.arguments()).hasSize(2);
tree = (MethodInvocationTree) expressionOfFirstStatement("class T { T() { <T>this(true, false); } }");
assertThat(tree.is(Tree.Kind.METHOD_INVOCATION)).isTrue();
assertThat(((IdentifierTree) tree.methodSelect()).name()).isEqualTo("this");
assertThat(tree.arguments()).hasSize(2);
tree = (MethodInvocationTree) expressionOfFirstStatement("class T { T() { super(true, false); } }");
assertThat(tree.is(Tree.Kind.METHOD_INVOCATION)).isTrue();
assertThat(((IdentifierTree) tree.methodSelect()).name()).isEqualTo("super");
assertThat(tree.arguments()).hasSize(2);
tree = (MethodInvocationTree) expressionOfFirstStatement("class T { T() { <T>super(true, false); } }");
assertThat(tree.is(Tree.Kind.METHOD_INVOCATION)).isTrue();
assertThat(((IdentifierTree) tree.methodSelect()).name()).isEqualTo("super");
assertThat(tree.arguments()).hasSize(2);
tree = (MethodInvocationTree) expressionOfFirstStatement("class T { T() { ClassName.super(true, false); } }");
assertThat(tree.is(Tree.Kind.METHOD_INVOCATION)).isTrue();
MemberSelectExpressionTree methodSelect = (MemberSelectExpressionTree) tree.methodSelect();
assertThatChildrenIteratorHasSize(methodSelect, 3);
assertThat(methodSelect.identifier().name()).isEqualTo("super");
assertThat(methodSelect.operatorToken()).isNotNull();
assertThat(((IdentifierTree) methodSelect.expression()).name()).isEqualTo("ClassName");
assertThat(tree.arguments()).hasSize(2);
tree = (MethodInvocationTree) expressionOfFirstStatement("class T { T() { ClassName.<T>super(true, false); } }");
assertThat(tree.is(Tree.Kind.METHOD_INVOCATION)).isTrue();
methodSelect = (MemberSelectExpressionTree) tree.methodSelect();
assertThatChildrenIteratorHasSize(methodSelect, 3);
assertThat(methodSelect.identifier().name()).isEqualTo("super");
assertThat(methodSelect.operatorToken()).isNotNull();
assertThat(((IdentifierTree) methodSelect.expression()).name()).isEqualTo("ClassName");
assertThat(tree.arguments()).hasSize(2);
}
@Test
public void array_field() {
VariableTree field;
ArrayTypeTree arrayTypeTree, childArrayTypeTree;
field = (VariableTree) firstTypeMember("class T { int[] a; }");
assertThatChildrenIteratorHasSize(field, 4);
assertThat(field.type()).isInstanceOf(ArrayTypeTree.class);
arrayTypeTree = (ArrayTypeTree) field.type();
assertThatArrayTypeHasBrackets(arrayTypeTree);
assertThatChildrenIteratorHasSize(arrayTypeTree, 3);
assertThat(arrayTypeTree.type()).isInstanceOf(PrimitiveTypeTree.class);
field = (VariableTree) firstTypeMember("class T { int[][] a; }");
assertThatChildrenIteratorHasSize(field, 4);
assertThat(field.type()).isInstanceOf(ArrayTypeTree.class);
arrayTypeTree = (ArrayTypeTree) field.type();
assertThatArrayTypeHasBrackets(arrayTypeTree);
assertThatChildrenIteratorHasSize(arrayTypeTree, 3);
assertThat(arrayTypeTree.type()).isInstanceOf(ArrayTypeTree.class);
childArrayTypeTree = (ArrayTypeTree) arrayTypeTree.type();
assertThatArrayTypeHasBrackets(childArrayTypeTree);
assertThatChildrenIteratorHasSize(arrayTypeTree, 3);
assertThat(childArrayTypeTree.openBracketToken().column() < arrayTypeTree.openBracketToken().column()).isTrue();
assertThat(childArrayTypeTree.type()).isInstanceOf(PrimitiveTypeTree.class);
field = (VariableTree) firstTypeMember("class T { int @Foo [] a; }");
assertThatChildrenIteratorHasSize(field, 4);
assertThat(field.type()).isInstanceOf(ArrayTypeTree.class);
arrayTypeTree = (ArrayTypeTree) field.type();
assertThat(arrayTypeTree.type()).isInstanceOf(PrimitiveTypeTree.class);
assertThatArrayTypeHasBracketsAndAnnotations(arrayTypeTree, 1);
assertThatChildrenIteratorHasSize(arrayTypeTree, 4);
field = (VariableTree) firstTypeMember("class T { int @Foo @bar [] a; }");
assertThatChildrenIteratorHasSize(field, 4);
assertThat(field.type()).isInstanceOf(ArrayTypeTree.class);
arrayTypeTree = (ArrayTypeTree) field.type();
assertThat(arrayTypeTree.type()).isInstanceOf(PrimitiveTypeTree.class);
assertThatArrayTypeHasBracketsAndAnnotations(arrayTypeTree, 2);
assertThatChildrenIteratorHasSize(arrayTypeTree, 5);
field = (VariableTree) firstTypeMember("class T { int[] @Foo [] a; }");
assertThatChildrenIteratorHasSize(field, 4);
assertThat(field.type()).isInstanceOf(ArrayTypeTree.class);
arrayTypeTree = (ArrayTypeTree) field.type();
assertThatArrayTypeHasBracketsAndAnnotations(arrayTypeTree, 1);
assertThatChildrenIteratorHasSize(arrayTypeTree, 4);
childArrayTypeTree = (ArrayTypeTree) arrayTypeTree.type();
assertThat(childArrayTypeTree).isInstanceOf(ArrayTypeTree.class);
assertThatArrayTypeHasBrackets(childArrayTypeTree);
assertThatChildrenIteratorHasSize(childArrayTypeTree, 3);
assertThat(childArrayTypeTree.openBracketToken().column() < arrayTypeTree.openBracketToken().column()).isTrue();
assertThat(childArrayTypeTree.type()).isInstanceOf(PrimitiveTypeTree.class);
field = (VariableTree) firstTypeMember("class T { int[] a[]; }");
assertThatChildrenIteratorHasSize(field, 4);
assertThat(field.type()).isInstanceOf(ArrayTypeTree.class);
arrayTypeTree = (ArrayTypeTree) field.type();
assertThatArrayTypeHasBrackets(arrayTypeTree);
assertThatChildrenIteratorHasSize(arrayTypeTree, 3);
childArrayTypeTree = (ArrayTypeTree) arrayTypeTree.type();
assertThat(childArrayTypeTree).isInstanceOf(ArrayTypeTree.class);
assertThatArrayTypeHasBrackets(childArrayTypeTree);
assertThatChildrenIteratorHasSize(childArrayTypeTree, 3);
assertThat(childArrayTypeTree.openBracketToken().column() < arrayTypeTree.openBracketToken().column()).isTrue();
assertThat(childArrayTypeTree.type()).isInstanceOf(PrimitiveTypeTree.class);
field = (VariableTree) firstTypeMember("class T { int[] a @Foo []; }");
assertThatChildrenIteratorHasSize(field, 4);
assertThat(field.type()).isInstanceOf(ArrayTypeTree.class);
arrayTypeTree = (ArrayTypeTree) field.type();
assertThat(arrayTypeTree).isInstanceOf(ArrayTypeTree.class);
assertThatArrayTypeHasBracketsAndAnnotations(arrayTypeTree, 1);
assertThatChildrenIteratorHasSize(arrayTypeTree, 4);
childArrayTypeTree = (ArrayTypeTree) arrayTypeTree.type();
assertThat(childArrayTypeTree).isInstanceOf(ArrayTypeTree.class);
assertThatArrayTypeHasBrackets(childArrayTypeTree);
assertThatChildrenIteratorHasSize(childArrayTypeTree, 3);
assertThat(childArrayTypeTree.openBracketToken().column() < arrayTypeTree.openBracketToken().column()).isTrue();
assertThat(childArrayTypeTree.type()).isInstanceOf(PrimitiveTypeTree.class);
}
@Test
public void array_method_return_type() {
MethodTree method;
ArrayTypeTree arrayTypeTree, childArrayTypeTree;
method = (MethodTree) firstTypeMember("class T { int[] m(); }");
assertThat(method.returnType()).isInstanceOf(ArrayTypeTree.class);
arrayTypeTree = (ArrayTypeTree) method.returnType();
assertThat(arrayTypeTree.type()).isInstanceOf(PrimitiveTypeTree.class);
assertThatArrayTypeHasBrackets(arrayTypeTree);
assertThatChildrenIteratorHasSize(arrayTypeTree, 3);
method = (MethodTree) firstTypeMember("class T { int @Foo [] m(); }");
assertThat(method.returnType()).isInstanceOf(ArrayTypeTree.class);
arrayTypeTree = (ArrayTypeTree) method.returnType();
assertThat(arrayTypeTree.type()).isInstanceOf(PrimitiveTypeTree.class);
assertThatArrayTypeHasBracketsAndAnnotations(arrayTypeTree, 1);
assertThatChildrenIteratorHasSize(arrayTypeTree, 4);
method = (MethodTree) firstTypeMember("class T { int @Foo @bar [] m(); }");
assertThat(method.returnType()).isInstanceOf(ArrayTypeTree.class);
arrayTypeTree = (ArrayTypeTree) method.returnType();
assertThat(arrayTypeTree.type()).isInstanceOf(PrimitiveTypeTree.class);
assertThatArrayTypeHasBracketsAndAnnotations(arrayTypeTree, 2);
assertThatChildrenIteratorHasSize(arrayTypeTree, 5);
method = (MethodTree) firstTypeMember("class T { int[] @Foo [] m(); }");
assertThat(method.returnType()).isInstanceOf(ArrayTypeTree.class);
arrayTypeTree = (ArrayTypeTree) method.returnType();
assertThatArrayTypeHasBracketsAndAnnotations(arrayTypeTree, 1);
assertThatChildrenIteratorHasSize(arrayTypeTree, 4);
childArrayTypeTree = (ArrayTypeTree) arrayTypeTree.type();
assertThat(childArrayTypeTree).isInstanceOf(ArrayTypeTree.class);
assertThatArrayTypeHasBrackets(childArrayTypeTree);
assertThatChildrenIteratorHasSize(childArrayTypeTree, 3);
assertThat(childArrayTypeTree.openBracketToken().column() < arrayTypeTree.openBracketToken().column()).isTrue();
assertThat(childArrayTypeTree.type()).isInstanceOf(PrimitiveTypeTree.class);
method = (MethodTree) firstTypeMember("class T { int[] m()[]; }");
assertThat(method.returnType()).isInstanceOf(ArrayTypeTree.class);
arrayTypeTree = (ArrayTypeTree) method.returnType();
assertThatArrayTypeHasBrackets(arrayTypeTree);
assertThatChildrenIteratorHasSize(arrayTypeTree, 3);
childArrayTypeTree = (ArrayTypeTree) arrayTypeTree.type();
assertThat(childArrayTypeTree).isInstanceOf(ArrayTypeTree.class);
assertThatArrayTypeHasBrackets(childArrayTypeTree);
assertThatChildrenIteratorHasSize(childArrayTypeTree, 3);
assertThat(childArrayTypeTree.openBracketToken().column() < arrayTypeTree.openBracketToken().column()).isTrue();
assertThat(childArrayTypeTree.type()).isInstanceOf(PrimitiveTypeTree.class);
method = (MethodTree) firstTypeMember("class T { int[] m() @Foo []; }");
assertThat(method.returnType()).isInstanceOf(ArrayTypeTree.class);
arrayTypeTree = (ArrayTypeTree) method.returnType();
assertThat(arrayTypeTree).isInstanceOf(ArrayTypeTree.class);
assertThatArrayTypeHasBracketsAndAnnotations(arrayTypeTree, 1);
assertThatChildrenIteratorHasSize(arrayTypeTree, 4);
childArrayTypeTree = (ArrayTypeTree) arrayTypeTree.type();
assertThat(childArrayTypeTree).isInstanceOf(ArrayTypeTree.class);
assertThatArrayTypeHasBrackets(childArrayTypeTree);
assertThatChildrenIteratorHasSize(childArrayTypeTree, 3);
assertThat(childArrayTypeTree.openBracketToken().column() < arrayTypeTree.openBracketToken().column()).isTrue();
assertThat(childArrayTypeTree.type()).isInstanceOf(PrimitiveTypeTree.class);
}
@Test
public void array_formal_parameter() {
MethodTree method;
VariableTree variable;
ArrayTypeTree arrayTypeTree, childArrayTypeTree;
method = (MethodTree) firstTypeMember("interface T { void m(int[] a); }");
variable = method.parameters().get(0);
assertThatChildrenIteratorHasSize(variable, 3); // 1+2, as empty modifiers are always included
assertThat(variable.type()).isInstanceOf(ArrayTypeTree.class);
arrayTypeTree = (ArrayTypeTree) variable.type();
assertThat(arrayTypeTree.type()).isInstanceOf(PrimitiveTypeTree.class);
assertThatArrayTypeHasBrackets(arrayTypeTree);
assertThatChildrenIteratorHasSize(arrayTypeTree, 3);
method = (MethodTree) firstTypeMember("interface T { void m(int... a); }");
variable = method.parameters().get(0);
assertThatChildrenIteratorHasSize(variable, 3);
assertThat(variable.type()).isInstanceOf(ArrayTypeTree.class);
arrayTypeTree = (ArrayTypeTree) variable.type();
assertThat(arrayTypeTree.type()).isInstanceOf(PrimitiveTypeTree.class);
assertThatArrayTypeHasEllipsis(arrayTypeTree);
assertThatChildrenIteratorHasSize(arrayTypeTree, 2);
method = (MethodTree) firstTypeMember("interface T { void m(int @Foo ... a); }");
variable = method.parameters().get(0);
assertThatChildrenIteratorHasSize(variable, 3);
assertThat(variable.type()).isInstanceOf(ArrayTypeTree.class);
arrayTypeTree = (ArrayTypeTree) variable.type();
assertThat(arrayTypeTree.type()).isInstanceOf(PrimitiveTypeTree.class);
assertThatArrayTypeHasEllipsisAndAnnotations(arrayTypeTree, 1);
assertThatChildrenIteratorHasSize(arrayTypeTree, 3);
method = (MethodTree) firstTypeMember("interface T { void m(int @Foo ... a[]); }");
variable = method.parameters().get(0);
assertThatChildrenIteratorHasSize(variable, 3);
assertThat(variable.type()).isInstanceOf(ArrayTypeTree.class);
arrayTypeTree = (ArrayTypeTree) variable.type();
assertThatArrayTypeHasBrackets(arrayTypeTree);
assertThatChildrenIteratorHasSize(arrayTypeTree, 3);
childArrayTypeTree = (ArrayTypeTree) arrayTypeTree.type();
assertThat(childArrayTypeTree).isInstanceOf(ArrayTypeTree.class);
assertThatArrayTypeHasEllipsisAndAnnotations(childArrayTypeTree, 1);
assertThatChildrenIteratorHasSize(childArrayTypeTree, 3);
assertThat(childArrayTypeTree.ellipsisToken().column() < arrayTypeTree.openBracketToken().column()).isTrue();
assertThat(childArrayTypeTree.type()).isInstanceOf(PrimitiveTypeTree.class);
method = (MethodTree) firstTypeMember("interface T { void m(int @Foo [] a); }");
assertThatChildrenIteratorHasSize(variable, 3);
variable = method.parameters().get(0);
assertThat(variable.type()).isInstanceOf(ArrayTypeTree.class);
arrayTypeTree = (ArrayTypeTree) variable.type();
assertThat(arrayTypeTree.type()).isInstanceOf(PrimitiveTypeTree.class);
assertThatArrayTypeHasBracketsAndAnnotations(arrayTypeTree, 1);
assertThatChildrenIteratorHasSize(arrayTypeTree, 4);
method = (MethodTree) firstTypeMember("interface T { void m(int @Foo @bar [] a); }");
variable = method.parameters().get(0);
assertThatChildrenIteratorHasSize(variable, 3);
assertThat(variable.type()).isInstanceOf(ArrayTypeTree.class);
arrayTypeTree = (ArrayTypeTree) variable.type();
assertThat(arrayTypeTree.type()).isInstanceOf(PrimitiveTypeTree.class);
assertThatArrayTypeHasBracketsAndAnnotations(arrayTypeTree, 2);
assertThatChildrenIteratorHasSize(arrayTypeTree, 5);
method = (MethodTree) firstTypeMember("interface T { void m(int[] @Foo [] a); }");
variable = method.parameters().get(0);
assertThatChildrenIteratorHasSize(variable, 3);
assertThat(variable.type()).isInstanceOf(ArrayTypeTree.class);
arrayTypeTree = (ArrayTypeTree) variable.type();
assertThatArrayTypeHasBracketsAndAnnotations(arrayTypeTree, 1);
assertThatChildrenIteratorHasSize(arrayTypeTree, 4);
childArrayTypeTree = (ArrayTypeTree) arrayTypeTree.type();
assertThat(childArrayTypeTree).isInstanceOf(ArrayTypeTree.class);
assertThatArrayTypeHasBrackets(childArrayTypeTree);
assertThatChildrenIteratorHasSize(childArrayTypeTree, 3);
assertThat(childArrayTypeTree.openBracketToken().column() < arrayTypeTree.openBracketToken().column()).isTrue();
assertThat(childArrayTypeTree.type()).isInstanceOf(PrimitiveTypeTree.class);
method = (MethodTree) firstTypeMember("interface T { void m(int[] a[]); }");
variable = method.parameters().get(0);
assertThatChildrenIteratorHasSize(variable, 3);
assertThat(variable.type()).isInstanceOf(ArrayTypeTree.class);
arrayTypeTree = (ArrayTypeTree) variable.type();
assertThatArrayTypeHasBrackets(arrayTypeTree);
assertThatChildrenIteratorHasSize(arrayTypeTree, 3);
childArrayTypeTree = (ArrayTypeTree) arrayTypeTree.type();
assertThat(childArrayTypeTree).isInstanceOf(ArrayTypeTree.class);
assertThatArrayTypeHasBrackets(childArrayTypeTree);
assertThatChildrenIteratorHasSize(childArrayTypeTree, 3);
assertThat(childArrayTypeTree.openBracketToken().column() < arrayTypeTree.openBracketToken().column()).isTrue();
assertThat(childArrayTypeTree.type()).isInstanceOf(PrimitiveTypeTree.class);
method = (MethodTree) firstTypeMember("interface T { void m(int[] a @Foo []); }");
variable = method.parameters().get(0);
assertThatChildrenIteratorHasSize(variable, 3);
assertThat(variable.type()).isInstanceOf(ArrayTypeTree.class);
arrayTypeTree = (ArrayTypeTree) variable.type();
assertThat(arrayTypeTree).isInstanceOf(ArrayTypeTree.class);
assertThatArrayTypeHasBracketsAndAnnotations(arrayTypeTree, 1);
assertThatChildrenIteratorHasSize(arrayTypeTree, 4);
childArrayTypeTree = (ArrayTypeTree) arrayTypeTree.type();
assertThat(childArrayTypeTree).isInstanceOf(ArrayTypeTree.class);
assertThatArrayTypeHasBrackets(childArrayTypeTree);
assertThatChildrenIteratorHasSize(childArrayTypeTree, 3);
assertThat(childArrayTypeTree.openBracketToken().column() < arrayTypeTree.openBracketToken().column()).isTrue();
assertThat(childArrayTypeTree.type()).isInstanceOf(PrimitiveTypeTree.class);
}
/**
* 15.13. Array Access Expressions
*/
@Test
public void array_access_expression() {
String code = "class T { T() { return a[42]; } }";
ArrayAccessExpressionTree tree = (ArrayAccessExpressionTree) expressionOfReturnStatement(code);
assertThat(tree.is(Tree.Kind.ARRAY_ACCESS_EXPRESSION)).isTrue();
assertThatChildrenIteratorHasSize(tree, 2);
assertThat(tree.expression()).isNotNull();
ArrayDimensionTree dimension = tree.dimension();
assertThat(dimension).isNotNull();
assertThat(dimension.openBracketToken().text()).isEqualTo("[");
assertThat(dimension.expression().is(Tree.Kind.INT_LITERAL)).isTrue();
assertThat(dimension.closeBracketToken().text()).isEqualTo("]");
assertThatChildrenIteratorHasSize(dimension, 3);
}
/**
* 15.14. Postfix Expressions
*/
@Test
public void postfix_expression() {
UnaryExpressionTree tree;
tree = (UnaryExpressionTree) ((ExpressionStatementTree) firstMethodFirstStatement(("class T { void m() { i++; } }"))).expression();
assertThat(tree.is(Tree.Kind.POSTFIX_INCREMENT)).isTrue();
assertThat(tree.expression()).isNotNull();
assertThat(tree.operatorToken().text()).isEqualTo("++");
assertThatChildrenIteratorHasSize(tree, 2);
tree = (UnaryExpressionTree) ((ExpressionStatementTree) firstMethodFirstStatement(("class T { void m() { i--; } }"))).expression();
assertThat(tree.is(Tree.Kind.POSTFIX_DECREMENT)).isTrue();
assertThat(tree.expression()).isNotNull();
assertThat(tree.operatorToken().text()).isEqualTo("--");
assertThatChildrenIteratorHasSize(tree, 2);
}
/**
* 15.15. Unary Operators
*/
@Test
public void unary_operators() {
UnaryExpressionTree tree;
tree = (UnaryExpressionTree) ((ExpressionStatementTree) firstMethodFirstStatement(("class T { void m() { ++i; } }"))).expression();
assertThat(tree.is(Tree.Kind.PREFIX_INCREMENT)).isTrue();
assertThat(tree.operatorToken().text()).isEqualTo("++");
assertThat(tree.expression()).isNotNull();
assertThatChildrenIteratorHasSize(tree, 2);
tree = (UnaryExpressionTree) ((ExpressionStatementTree) firstMethodFirstStatement(("class T { void m() { --i; } }"))).expression();
assertThat(tree.is(Tree.Kind.PREFIX_DECREMENT)).isTrue();
assertThat(tree.operatorToken().text()).isEqualTo("--");
assertThat(tree.expression()).isNotNull();
assertThatChildrenIteratorHasSize(tree, 2);
}
/**
* 15.16. Cast Expressions
*/
@Test
public void type_cast() {
TypeCastTree tree = (TypeCastTree) expressionOfReturnStatement("class T { boolean m() { return (Boolean) true; } }");
assertThat(tree.is(Tree.Kind.TYPE_CAST)).isTrue();
assertThat(tree.openParenToken().text()).isEqualTo("(");
assertThat(tree.type()).isNotNull();
assertThat(tree.closeParenToken().text()).isEqualTo(")");
assertThat(tree.expression()).isNotNull();
assertThatChildrenIteratorHasSize(tree, 5);
tree = (TypeCastTree) expressionOfReturnStatement("class T { boolean m() { return (Foo<T> & Bar) true; } }");
assertThat(tree.is(Tree.Kind.TYPE_CAST)).isTrue();
assertThat(tree.openParenToken().text()).isEqualTo("(");
assertThat(tree.type()).isNotNull();
assertThat(tree.andToken()).isNotNull();
assertThat(tree.bounds()).hasSize(1);
assertThat(tree.closeParenToken().text()).isEqualTo(")");
assertThat(tree.expression()).isNotNull();
assertThatChildrenIteratorHasSize(tree, 6);
tree = (TypeCastTree) expressionOfReturnStatement("class T { boolean m() { return (Foo<T> & @Gul Bar) true; } }");
assertThat(tree.is(Tree.Kind.TYPE_CAST)).isTrue();
assertThat(tree.openParenToken().text()).isEqualTo("(");
assertThat(tree.type()).isNotNull();
assertThat(tree.andToken()).isNotNull();
assertThat(tree.bounds()).hasSize(1);
assertThat(tree.bounds().separators()).isEmpty();
assertThat(tree.closeParenToken().text()).isEqualTo(")");
assertThat(tree.expression()).isNotNull();
assertThatChildrenIteratorHasSize(tree, 6);
tree = (TypeCastTree) expressionOfReturnStatement("class T { boolean m() { return (Foo<T> & @Gul Bar & Qix & Plop) true; } }");
assertThat(tree.is(Tree.Kind.TYPE_CAST)).isTrue();
assertThat(tree.openParenToken().text()).isEqualTo("(");
assertThat(tree.type()).isNotNull();
assertThat(tree.andToken()).isNotNull();
assertThat(tree.bounds()).hasSize(3);
assertThat(tree.bounds().separators()).hasSize(2);
assertThat(tree.closeParenToken().text()).isEqualTo(")");
assertThat(tree.expression()).isNotNull();
assertThatChildrenIteratorHasSize(tree, 6);
}
/**
* 15.17. Multiplicative Operators
*/
@Test
public void multiplicative_expression() {
String code = "class T { int m() { return 1 * 2 / 3 % 4; } }";
BinaryExpressionTree tree = (BinaryExpressionTree) expressionOfReturnStatement(code);
assertThat(tree.is(Kind.REMAINDER)).isTrue();
assertThat(tree.leftOperand()).isNotNull();
assertThat(tree.operatorToken().text()).isEqualTo("%");
assertThat(tree.rightOperand()).isNotNull();
assertThatChildrenIteratorHasSize(tree, 3);
tree = (BinaryExpressionTree) tree.leftOperand();
assertThat(tree.is(Tree.Kind.DIVIDE)).isTrue();
assertThat(tree.leftOperand()).isNotNull();
assertThat(tree.operatorToken().text()).isEqualTo("/");
assertThat(tree.rightOperand()).isNotNull();
assertThatChildrenIteratorHasSize(tree, 3);
tree = (BinaryExpressionTree) tree.leftOperand();
assertThat(tree.is(Kind.MULTIPLY)).isTrue();
assertThat(tree.leftOperand()).isNotNull();
assertThat(tree.operatorToken().text()).isEqualTo("*");
assertThat(tree.rightOperand()).isNotNull();
assertThatChildrenIteratorHasSize(tree, 3);
}
/**
* 15.18. Additive Operators
*/
@Test
public void additive_expression() {
String code = "class T { int m() { return 1 + 2 - 3; } }";
BinaryExpressionTree tree = (BinaryExpressionTree) expressionOfReturnStatement(code);
assertThat(tree.is(Kind.MINUS)).isTrue();
assertThat(tree.leftOperand()).isNotNull();
assertThat(tree.operatorToken().text()).isEqualTo("-");
assertThat(tree.rightOperand()).isNotNull();
assertThat(tree.rightOperand().is(Kind.INT_LITERAL)).isTrue();
assertThatChildrenIteratorHasSize(tree, 3);
tree = (BinaryExpressionTree) tree.leftOperand();
assertThat(tree.is(Kind.PLUS)).isTrue();
assertThat(tree.leftOperand()).isNotNull();
assertThat(tree.operatorToken().text()).isEqualTo("+");
assertThat(tree.rightOperand()).isNotNull();
assertThatChildrenIteratorHasSize(tree, 3);
}
/**
* 15.19. Shift Operators
*/
@Test
public void shift_expression() {
String code = "class T { int m() { return 1 >> 2 << 3 >>> 4; } }";
BinaryExpressionTree tree = (BinaryExpressionTree) (BinaryExpressionTree) expressionOfReturnStatement(code);
assertThat(tree.is(Tree.Kind.UNSIGNED_RIGHT_SHIFT)).isTrue();
assertThat(tree.leftOperand()).isNotNull();
assertThat(tree.operatorToken().text()).isEqualTo(">>>");
assertThat(tree.rightOperand()).isNotNull();
assertThatChildrenIteratorHasSize(tree, 3);
tree = (BinaryExpressionTree) tree.leftOperand();
assertThat(tree.is(Tree.Kind.LEFT_SHIFT)).isTrue();
assertThat(tree.leftOperand()).isNotNull();
assertThat(tree.operatorToken().text()).isEqualTo("<<");
assertThat(tree.rightOperand()).isNotNull();
assertThatChildrenIteratorHasSize(tree, 3);
tree = (BinaryExpressionTree) tree.leftOperand();
assertThat(tree.is(Kind.RIGHT_SHIFT)).isTrue();
assertThat(tree.leftOperand()).isNotNull();
assertThat(tree.operatorToken().text()).isEqualTo(">>");
assertThat(tree.rightOperand()).isNotNull();
assertThatChildrenIteratorHasSize(tree, 3);
}
/**
* 15.20. Relational Operators
*/
@Test
public void relational_expression() {
String code = "class T { boolean m() { return 1 < 2 > 3; } }";
BinaryExpressionTree tree = (BinaryExpressionTree) (BinaryExpressionTree) expressionOfReturnStatement(code);
assertThat(tree.is(Tree.Kind.GREATER_THAN)).isTrue();
assertThat(tree.leftOperand()).isNotNull();
assertThat(tree.operatorToken().text()).isEqualTo(">");
assertThat(tree.rightOperand()).isNotNull();
assertThatChildrenIteratorHasSize(tree, 3);
tree = (BinaryExpressionTree) tree.leftOperand();
assertThat(tree.is(Kind.LESS_THAN)).isTrue();
assertThat(tree.leftOperand()).isNotNull();
assertThat(tree.operatorToken().text()).isEqualTo("<");
assertThat(tree.rightOperand()).isNotNull();
assertThatChildrenIteratorHasSize(tree, 3);
}
/**
* 15.20.2. Type Comparison Operator instanceof
*/
@Test
public void instanceof_expression() {
InstanceOfTree tree = (InstanceOfTree) expressionOfReturnStatement("class T { boolean m() { return null instanceof Object; } }");
assertThat(tree.is(Tree.Kind.INSTANCE_OF)).isTrue();
assertThat(tree.expression()).isNotNull();
assertThat(tree.instanceofKeyword().text()).isEqualTo("instanceof");
assertThat(tree.type()).isNotNull();
assertThatChildrenIteratorHasSize(tree, 3);
}
/**
* 15.21. Equality Operators
*/
@Test
public void equality_expression() {
String code = "class T { boolean m() { return false == false != true; } }";
BinaryExpressionTree tree = (BinaryExpressionTree) (BinaryExpressionTree) expressionOfReturnStatement(code);
assertThat(tree.is(Tree.Kind.NOT_EQUAL_TO)).isTrue();
assertThat(tree.leftOperand()).isNotNull();
assertThat(tree.operatorToken().text()).isEqualTo("!=");
assertThat(tree.rightOperand()).isNotNull();
assertThatChildrenIteratorHasSize(tree, 3);
tree = (BinaryExpressionTree) tree.leftOperand();
assertThat(tree.is(Tree.Kind.EQUAL_TO)).isTrue();
assertThat(tree.leftOperand()).isNotNull();
assertThat(tree.operatorToken().text()).isEqualTo("==");
assertThat(tree.rightOperand()).isNotNull();
assertThatChildrenIteratorHasSize(tree, 3);
}
/**
* 15.22. Bitwise and Logical Operators
*/
@Test
public void bitwise_and_logical_operators() {
String code = "class T { int m() { return 1 & 2 & 3; } }";
BinaryExpressionTree tree = (BinaryExpressionTree) expressionOfReturnStatement(code);
assertThat(tree.is(Tree.Kind.AND)).isTrue();
assertThat(tree.leftOperand()).isNotNull();
assertThat(tree.operatorToken().text()).isEqualTo("&");
assertThat(tree.rightOperand()).isNotNull();
assertThatChildrenIteratorHasSize(tree, 3);
tree = (BinaryExpressionTree) tree.leftOperand();
assertThat(tree.is(Tree.Kind.AND)).isTrue();
assertThat(tree.leftOperand()).isNotNull();
assertThat(tree.operatorToken().text()).isEqualTo("&");
assertThat(tree.rightOperand()).isNotNull();
assertThatChildrenIteratorHasSize(tree, 3);
code = "class T { int m() { return 1 ^ 2 ^ 3; } }";
tree = (BinaryExpressionTree) expressionOfReturnStatement(code);
assertThat(tree.is(Tree.Kind.XOR)).isTrue();
assertThat(tree.leftOperand()).isNotNull();
assertThat(tree.operatorToken().text()).isEqualTo("^");
assertThat(tree.rightOperand()).isNotNull();
assertThatChildrenIteratorHasSize(tree, 3);
tree = (BinaryExpressionTree) tree.leftOperand();
assertThat(tree.is(Tree.Kind.XOR)).isTrue();
assertThat(tree.leftOperand()).isNotNull();
assertThat(tree.operatorToken().text()).isEqualTo("^");
assertThat(tree.rightOperand()).isNotNull();
assertThatChildrenIteratorHasSize(tree, 3);
code = "class T { int m() { return 1 | 2 | 3; } }";
tree = (BinaryExpressionTree) expressionOfReturnStatement(code);
assertThat(tree.is(Tree.Kind.OR)).isTrue();
assertThat(tree.leftOperand()).isNotNull();
assertThat(tree.operatorToken().text()).isEqualTo("|");
assertThat(tree.rightOperand()).isNotNull();
assertThatChildrenIteratorHasSize(tree, 3);
tree = (BinaryExpressionTree) tree.leftOperand();
assertThat(tree.is(Tree.Kind.OR)).isTrue();
assertThat(tree.leftOperand()).isNotNull();
assertThat(tree.operatorToken().text()).isEqualTo("|");
assertThat(tree.rightOperand()).isNotNull();
assertThatChildrenIteratorHasSize(tree, 3);
}
/**
* 15.23. Conditional-And Operator &&
*/
@Test
public void conditional_and_expression() {
String code = "class T { boolean m() { return false && false && true; } }";
BinaryExpressionTree tree = (BinaryExpressionTree) expressionOfReturnStatement(code);
assertThat(tree.is(Tree.Kind.CONDITIONAL_AND)).isTrue();
assertThat(tree.leftOperand()).isNotNull();
assertThat(tree.operatorToken().text()).isEqualTo("&&");
assertThat(tree.rightOperand()).isNotNull();
assertThatChildrenIteratorHasSize(tree, 3);
tree = (BinaryExpressionTree) tree.leftOperand();
assertThat(tree.is(Tree.Kind.CONDITIONAL_AND)).isTrue();
assertThat(tree.leftOperand()).isNotNull();
assertThat(tree.operatorToken().text()).isEqualTo("&&");
assertThat(tree.rightOperand()).isNotNull();
assertThatChildrenIteratorHasSize(tree, 3);
}
/**
* 15.24. Conditional-Or Operator ||
*/
@Test
public void conditional_or_expression() {
String code = "class T { boolean m() { return false || false || true; } }";
BinaryExpressionTree tree = (BinaryExpressionTree) expressionOfReturnStatement(code);
assertThat(tree.is(Tree.Kind.CONDITIONAL_OR)).isTrue();
assertThat(tree.leftOperand()).isNotNull();
assertThat(tree.operatorToken().text()).isEqualTo("||");
assertThat(tree.rightOperand()).isNotNull();
assertThatChildrenIteratorHasSize(tree, 3);
tree = (BinaryExpressionTree) tree.leftOperand();
assertThat(tree.is(Tree.Kind.CONDITIONAL_OR)).isTrue();
assertThat(tree.leftOperand()).isNotNull();
assertThat(tree.operatorToken().text()).isEqualTo("||");
assertThat(tree.rightOperand()).isNotNull();
assertThatChildrenIteratorHasSize(tree, 3);
}
/**
* 15.25. Conditional Operator ? :
*/
@Test
public void conditional_expression() {
ConditionalExpressionTree tree;
tree = (ConditionalExpressionTree) expressionOfReturnStatement("class T { boolean m() { return true ? true : false; } }");
assertThat(tree.is(Tree.Kind.CONDITIONAL_EXPRESSION)).isTrue();
assertThat(tree.condition()).isInstanceOf(LiteralTree.class);
assertThat(tree.questionToken().text()).isEqualTo("?");
assertThat(tree.trueExpression()).isInstanceOf(LiteralTree.class);
assertThat(tree.colonToken().text()).isEqualTo(":");
assertThat(tree.falseExpression()).isInstanceOf(LiteralTree.class);
assertThatChildrenIteratorHasSize(tree, 5);
tree = (ConditionalExpressionTree) expressionOfReturnStatement("class T { boolean m() { return true ? true : false ? true : false; } }");
assertThat(tree.is(Tree.Kind.CONDITIONAL_EXPRESSION)).isTrue();
assertThat(tree.condition()).isInstanceOf(LiteralTree.class);
assertThat(tree.trueExpression()).isInstanceOf(LiteralTree.class);
assertThat(tree.falseExpression()).isInstanceOf(ConditionalExpressionTree.class);
assertThatChildrenIteratorHasSize(tree, 5);
tree = (ConditionalExpressionTree) tree.falseExpression();
assertThat(tree.is(Tree.Kind.CONDITIONAL_EXPRESSION)).isTrue();
assertThat(tree.condition()).isInstanceOf(LiteralTree.class);
assertThat(tree.trueExpression()).isInstanceOf(LiteralTree.class);
assertThat(tree.falseExpression()).isInstanceOf(LiteralTree.class);
assertThatChildrenIteratorHasSize(tree, 5);
}
/**
* 15.26. Assignment Operators
*/
@Test
public void assignment_expression() {
String code = "class T { void m() { a += 42; } }";
AssignmentExpressionTree tree = (AssignmentExpressionTree) ((ExpressionStatementTree) firstMethodFirstStatement(code)).expression();
assertThat(tree.is(Tree.Kind.PLUS_ASSIGNMENT)).isTrue();
assertThat(tree.variable()).isNotNull();
assertThat(tree.operatorToken().text()).isEqualTo("+=");
assertThat(tree.expression()).isNotNull();
assertThatChildrenIteratorHasSize(tree, 3);
}
@Test
public void method_reference_expression_should_not_break_AST() throws Exception {
String code = "class T { public void meth(){IntStream.range(1,12).map(new MethodReferences()::<String>square).map(super::myMethod).map(int[]::new).forEach(System.out::println);}}";
MethodInvocationTree mit = (MethodInvocationTree) ((ExpressionStatementTree) firstMethodFirstStatement(code)).expression();
MethodReferenceTree mrt = (MethodReferenceTree) mit.arguments().get(0);
assertThat(mrt.expression().is(Kind.MEMBER_SELECT)).isTrue();
assertThat(mrt.doubleColon()).isNotNull();
assertThatChildrenIteratorHasSize(mrt, 3);
mit = (MethodInvocationTree) ((MemberSelectExpressionTree) mit.methodSelect()).expression();
mrt = (MethodReferenceTree) mit.arguments().get(0);
assertThat(mrt.expression().is(Kind.ARRAY_TYPE)).isTrue();
assertThat(mrt.doubleColon()).isNotNull();
assertThat(mrt.method().name()).isEqualTo("new");
assertThatChildrenIteratorHasSize(mrt, 3);
mit = (MethodInvocationTree) ((MemberSelectExpressionTree) mit.methodSelect()).expression();
mrt = (MethodReferenceTree) mit.arguments().get(0);
assertThat(mrt.expression().is(Kind.IDENTIFIER)).isTrue();
assertThat(((IdentifierTree) mrt.expression()).name()).isEqualTo("super");
assertThat(mrt.doubleColon()).isNotNull();
assertThatChildrenIteratorHasSize(mrt, 3);
mit = (MethodInvocationTree) ((MemberSelectExpressionTree) mit.methodSelect()).expression();
mrt = (MethodReferenceTree) mit.arguments().get(0);
assertThat(mrt.expression().is(Kind.NEW_CLASS)).isTrue();
assertThat(mrt.doubleColon()).isNotNull();
assertThat(mrt.typeArguments()).isNotNull();
assertThat(mrt.method().name()).isEqualTo("square");
assertThatChildrenIteratorHasSize(mrt, 4);
}
@Test
public void lambda_expressions() {
String code = "class T { public void meth(){IntStream.range(1,12).map(x->x*x).map((int a)-> {return a*a;});}}";
ExpressionTree expressionTree = ((ExpressionStatementTree) firstMethodFirstStatement(code)).expression();
// parsing not broken by lambda
assertThat(expressionTree).isNotNull();
MethodInvocationTree mit = (MethodInvocationTree) expressionTree;
LambdaExpressionTree tree = (LambdaExpressionTree) mit.arguments().get(0);
assertThat(tree.openParenToken()).isNotNull();
assertThat(tree.parameters()).hasSize(1);
assertThat(tree.parameters().get(0).is(Tree.Kind.VARIABLE)).isTrue();
assertThat(tree.closeParenToken()).isNotNull();
assertThat(tree.arrowToken()).isNotNull();
assertThat(tree.body().is(Tree.Kind.BLOCK)).isTrue();
tree = (LambdaExpressionTree) ((MethodInvocationTree) ((MemberSelectExpressionTree) mit.methodSelect()).expression()).arguments().get(0);
assertThat(tree.openParenToken()).isNull();
assertThat(tree.parameters()).hasSize(1);
assertThat(tree.parameters().get(0).is(Tree.Kind.VARIABLE)).isTrue();
assertThat(tree.closeParenToken()).isNull();
assertThat(tree.arrowToken()).isNotNull();
assertThat(tree.body().is(Tree.Kind.MULTIPLY)).isTrue();
}
@Test
public void type_parameters_tokens() {
ParameterizedTypeTree tree = (ParameterizedTypeTree) firstType("class Foo<E> extends List<E> {}").superClass();
assertThat(tree).isNotNull();
assertThatChildrenIteratorHasSize(tree, 2);
TypeArguments typeArguments = tree.typeArguments();
assertThat(typeArguments).isNotNull();
assertThat(typeArguments).hasSize(1);
assertThat(typeArguments.separators()).isEmpty();
assertThat(typeArguments.openBracketToken()).isNotNull();
assertThat(typeArguments.closeBracketToken()).isNotNull();
assertThatChildrenIteratorHasSize(typeArguments, 3);
tree = (ParameterizedTypeTree) firstType("class Mop<K,V> implements Map<K,V> {}").superInterfaces().get(0);
assertThat(tree).isNotNull();
assertThatChildrenIteratorHasSize(tree, 2);
typeArguments = tree.typeArguments();
assertThat(typeArguments).isNotNull();
assertThat(typeArguments).hasSize(2);
assertThat(typeArguments.separators()).hasSize(1);
assertThat(typeArguments.openBracketToken()).isNotNull();
assertThat(typeArguments.closeBracketToken()).isNotNull();
assertThatChildrenIteratorHasSize(typeArguments, 5);
}
@Test
public void type_parameters_and_bounds() {
TypeParameterListTreeImpl tree = (TypeParameterListTreeImpl) firstType("class Foo<T, U extends Object & Number> {}").typeParameters();
assertThat(tree.openBracketToken().text()).isEqualTo("<");
assertThat(tree.closeBracketToken().text()).isEqualTo(">");
assertThat(tree).hasSize(2);
assertThat(tree.separators()).hasSize(1);
assertThatChildrenIteratorHasSize(tree, 5);
TypeParameterTree param = tree.get(0);
assertThat(param.identifier().name()).isEqualTo("T");
assertThat(param.bounds()).isEmpty();
assertThat(param.bounds().separators()).isEmpty();
assertThatChildrenIteratorHasSize(param, 1);
param = tree.get(1);
assertThat(param.identifier().name()).isEqualTo("U");
assertThat(param.bounds()).hasSize(2);
assertThat(param.bounds().separators()).hasSize(1);
assertThat(((IdentifierTree) param.bounds().get(0)).name()).isEqualTo("Object");
assertThat(((IdentifierTree) param.bounds().get(1)).name()).isEqualTo("Number");
assertThatChildrenIteratorHasSize(param, 3);
}
private ExpressionTree expressionOfReturnStatement(String code) {
return ((ReturnStatementTree) firstMethodFirstStatement(code)).expression();
}
private ExpressionTree expressionOfFirstStatement(String code) {
return ((ExpressionStatementTree) firstMethodFirstStatement(code)).expression();
}
private StatementTree firstMethodFirstStatement(String code) {
return ((MethodTree) firstTypeMember(code)).block().body().get(0);
}
private Tree firstTypeMember(String code) {
return firstType(code).members().get(0);
}
private ClassTree firstType(String code) {
return (ClassTree) compilationUnit(code).types().get(0);
}
private CompilationUnitTree compilationUnit(String code) {
return (CompilationUnitTree) p.parse(code);
}
private static void assertThatArrayTypeHasBrackets(ArrayTypeTree tree) {
assertThatArrayTypeHasBrackets(tree, 0, false);
}
private static void assertThatArrayTypeHasBracketsAndAnnotations(ArrayTypeTree tree, int numberAnnotations) {
assertThatArrayTypeHasBrackets(tree, numberAnnotations, false);
}
private static void assertThatArrayTypeHasEllipsisAndAnnotations(ArrayTypeTree tree, int numberAnnotations) {
assertThatArrayTypeHasBrackets(tree, numberAnnotations, true);
}
private static void assertThatArrayTypeHasEllipsis(ArrayTypeTree tree) {
assertThatArrayTypeHasBrackets(tree, 0, true);
}
private static void assertThatChildrenIteratorHasSize(Tree tree, int size) {
List<Tree> children = ImmutableList.<Tree>builder().addAll(((JavaTree) tree).getChildren()).build();
assertThat(children).hasSize(size);
}
private static void assertThatArrayTypeHasBrackets(ArrayTypeTree tree, int numberAnnotations, boolean shouldHaveEllipsis) {
assertThat(tree.annotations()).hasSize(numberAnnotations);
if (shouldHaveEllipsis) {
assertThat(tree.ellipsisToken().text()).isEqualTo("...");
assertThat(tree.openBracketToken()).isNull();
assertThat(tree.closeBracketToken()).isNull();
} else {
assertThat(tree.ellipsisToken()).isNull();
assertThat(tree.openBracketToken().text()).isEqualTo("[");
assertThat(tree.closeBracketToken().text()).isEqualTo("]");
}
}
}