1 files changed, 188 insertions, 0 deletions
diff --git a/javaparser-testing/src/test/java/com/github/javaparser/ast/type/ArrayTypeTest.java b/javaparser-testing/src/test/java/com/github/javaparser/ast/type/ArrayTypeTest.java
new file mode 100644
index 000000000..3fdee8e43
--- /dev/null
+++ b/javaparser-testing/src/test/java/com/github/javaparser/ast/type/ArrayTypeTest.java
@@ -0,0 +1,188 @@
+/*
+ * Copyright (C) 2007-2010 Júlio Vilmar Gesser.
+ * Copyright (C) 2011, 2013-2016 The JavaParser Team.
+ *
+ * This file is part of JavaParser.
+ *
+ * JavaParser can be used either under the terms of
+ * a) 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.
+ * b) the terms of the Apache License
+ *
+ * You should have received a copy of both licenses in LICENCE.LGPL and
+ * LICENCE.APACHE. Please refer to those files for details.
+ *
+ * JavaParser 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.
+ */
+
+package com.github.javaparser.ast.type;
+
+import com.github.javaparser.ast.body.FieldDeclaration;
+import com.github.javaparser.ast.body.MethodDeclaration;
+import com.github.javaparser.ast.body.Parameter;
+import com.github.javaparser.ast.expr.ArrayCreationExpr;
+import com.github.javaparser.ast.expr.MarkerAnnotationExpr;
+import com.github.javaparser.ast.expr.Name;
+import com.github.javaparser.ast.expr.VariableDeclarationExpr;
+import com.github.javaparser.ast.stmt.ExpressionStmt;
+import com.github.javaparser.printer.ConcreteSyntaxModel;
+import org.assertj.core.api.Assertions;
+import org.junit.Test;
+
+import static com.github.javaparser.JavaParser.*;
+import static com.github.javaparser.utils.Utils.EOL;
+import static org.assertj.core.api.Assertions.*;
+import static org.assertj.core.api.Assertions.assertThat;
+import static org.junit.Assert.assertEquals;
+
+public class ArrayTypeTest {
+    @Test
+    public void getFieldDeclarationWithArrays() {
+        FieldDeclaration fieldDeclaration = parseBodyDeclaration("@C int @A[] @B[] a @X[] @Y[];").asFieldDeclaration();
+
+        ArrayType arrayType1 = fieldDeclaration.getVariable(0).getType().asArrayType();
+        ArrayType arrayType2 = arrayType1.getComponentType().asArrayType();
+        ArrayType arrayType3 = arrayType2.getComponentType().asArrayType();
+        ArrayType arrayType4 = arrayType3.getComponentType().asArrayType();
+        PrimitiveType elementType = arrayType4.getComponentType().asPrimitiveType();
+
+        assertThat(arrayType1.getAnnotations()).containsExactly(new MarkerAnnotationExpr(parseName("A")));
+        assertThat(arrayType2.getAnnotations()).containsExactly(new MarkerAnnotationExpr(parseName("B")));
+        assertThat(arrayType3.getAnnotations()).containsExactly(new MarkerAnnotationExpr(parseName("X")));
+        assertThat(arrayType4.getAnnotations()).containsExactly(new MarkerAnnotationExpr(parseName("Y")));
+
+        assertThat(elementType.getType()).isEqualTo(PrimitiveType.Primitive.INT);
+        assertThat(fieldDeclaration.getAnnotations()).containsExactly(new MarkerAnnotationExpr(parseName("C")));
+
+        assertThat(arrayType1.getParentNode().get().getParentNode().get()).isSameAs(fieldDeclaration);
+    }
+
+    @Test
+    public void getVariableDeclarationWithArrays() {
+        ExpressionStmt variableDeclarationStatement = parseStatement("@C int @A[] @B[] a @X[] @Y[];").asExpressionStmt();
+        VariableDeclarationExpr variableDeclarationExpr = variableDeclarationStatement.getExpression().asVariableDeclarationExpr();
+
+        ArrayType arrayType1 = variableDeclarationExpr.getVariable(0).getType().asArrayType();
+        ArrayType arrayType2 = arrayType1.getComponentType().asArrayType();
+        ArrayType arrayType3 = arrayType2.getComponentType().asArrayType();
+        ArrayType arrayType4 = arrayType3.getComponentType().asArrayType();
+        PrimitiveType elementType = arrayType4.getComponentType().asPrimitiveType();
+
+        assertThat(arrayType1.getAnnotations()).containsExactly(new MarkerAnnotationExpr(parseName("A")));
+        assertThat(arrayType2.getAnnotations()).containsExactly(new MarkerAnnotationExpr(parseName("B")));
+        assertThat(arrayType3.getAnnotations()).containsExactly(new MarkerAnnotationExpr(parseName("X")));
+        assertThat(arrayType4.getAnnotations()).containsExactly(new MarkerAnnotationExpr(parseName("Y")));
+
+        assertThat(elementType.getType()).isEqualTo(PrimitiveType.Primitive.INT);
+        assertThat(variableDeclarationExpr.getAnnotations()).containsExactly(new MarkerAnnotationExpr(parseName("C")));
+
+        assertThat(arrayType1.getParentNode().get().getParentNode().get()).isSameAs(variableDeclarationExpr);
+    }
+
+    @Test
+    public void getMethodDeclarationWithArrays() {
+        MethodDeclaration methodDeclaration = parseBodyDeclaration("@C int @A[] a() @B[] {}").asMethodDeclaration();
+
+        ArrayType arrayType1 = methodDeclaration.getType().asArrayType();
+        ArrayType arrayType2 = arrayType1.getComponentType().asArrayType();
+        Type elementType = arrayType2.getComponentType();
+        assertThat(elementType).isInstanceOf(PrimitiveType.class);
+
+        assertThat(arrayType1.getAnnotations()).containsExactly(new MarkerAnnotationExpr(parseName("A")));
+        assertThat(arrayType2.getAnnotations()).containsExactly(new MarkerAnnotationExpr(parseName("B")));
+        assertThat(methodDeclaration.getAnnotations()).containsExactly(new MarkerAnnotationExpr(parseName("C")));
+
+        assertThat(methodDeclaration.getType().getParentNode().get()).isSameAs(methodDeclaration);
+    }
+
+    @Test
+    public void getParameterWithArrays() {
+        MethodDeclaration methodDeclaration = parseBodyDeclaration("void a(@C int @A[] a @B[]) {}").asMethodDeclaration();
+
+        Parameter parameter = methodDeclaration.getParameter(0);
+
+        ArrayType outerArrayType = parameter.getType().asArrayType();
+
+        ArrayType innerArrayType = outerArrayType.getComponentType().asArrayType();
+        PrimitiveType elementType = innerArrayType.getComponentType().asPrimitiveType();
+
+        assertThat(elementType).isInstanceOf(PrimitiveType.class);
+        assertThat(outerArrayType.getAnnotations()).containsExactly(new MarkerAnnotationExpr(parseName("A")));
+        assertThat(innerArrayType.getAnnotations()).containsExactly(new MarkerAnnotationExpr(parseName("B")));
+        assertThat(parameter.getAnnotations()).containsExactly(new MarkerAnnotationExpr(parseName("C")));
+
+        assertThat(parameter.getType().getParentNode().get()).isSameAs(parameter);
+    }
+
+    @Test
+    public void setVariableDeclarationWithArrays() {
+        ExpressionStmt variableDeclarationStatement = parseStatement("@C int @A[] @B[] a @X[] @Y[];").asExpressionStmt();
+        VariableDeclarationExpr variableDeclarationExpr = variableDeclarationStatement.getExpression().asVariableDeclarationExpr();
+
+        variableDeclarationExpr.getVariable(0).setType(new ArrayType(new ArrayType(PrimitiveType.intType())));
+        assertEquals("@C int[][] a;", variableDeclarationStatement.toString());
+    }
+
+    @Test
+    public void setFieldDeclarationWithArrays() {
+        FieldDeclaration fieldDeclaration = parseBodyDeclaration("int[][] a[][];").asFieldDeclaration();
+        fieldDeclaration.getVariable(0).setType(new ArrayType(new ArrayType(parseClassOrInterfaceType("Blob"))));
+
+        assertEquals("Blob[][] a;", fieldDeclaration.toString());
+    }
+
+    @Test
+    public void setMethodDeclarationWithArrays() {
+        MethodDeclaration method = parseBodyDeclaration("int[][] a()[][] {}").asMethodDeclaration();
+        method.setType(new ArrayType(new ArrayType(parseClassOrInterfaceType("Blob"))));
+
+        assertEquals("Blob[][] a() {" + EOL + "}", method.toString());
+    }
+
+    @Test
+    public void fieldDeclarationWithArraysHasCorrectOrigins() {
+        FieldDeclaration fieldDeclaration = parseBodyDeclaration("int[] a[];").asFieldDeclaration();
+
+        Type outerType = fieldDeclaration.getVariables().get(0).getType();
+        assertEquals(ArrayType.Origin.TYPE, outerType.asArrayType().getOrigin());
+        assertEquals(ArrayType.Origin.NAME, outerType.asArrayType().getComponentType().asArrayType().getOrigin());
+    }
+
+    @Test
+    public void methodDeclarationWithArraysHasCorrectOrigins() {
+        MethodDeclaration method = (MethodDeclaration) parseBodyDeclaration("int[] a()[] {}");
+
+        Type outerType = method.getType();
+        assertEquals(ArrayType.Origin.TYPE, outerType.asArrayType().getOrigin());
+        assertEquals(ArrayType.Origin.NAME, outerType.asArrayType().getComponentType().asArrayType().getOrigin());
+    }
+
+    @Test
+    public void setParameterWithArrays() {
+        MethodDeclaration method = parseBodyDeclaration("void a(int[][] a[][]) {}").asMethodDeclaration();
+        method.getParameter(0).setType(new ArrayType(new ArrayType(parseClassOrInterfaceType("Blob"))));
+
+        assertEquals("void a(Blob[][] a) {" + EOL + "}", method.toString());
+    }
+
+    @Test
+    public void getArrayCreationType() {
+        ArrayCreationExpr expr = parseExpression("new int[]");
+        ArrayType outerType = expr.createdType().asArrayType();
+        Type innerType = outerType.getComponentType();
+        assertThat(innerType).isEqualTo(expr.getElementType());
+    }
+    
+    @Test
+    public void ellipsisCanHaveAnnotationsToo() {
+        Parameter p = parseParameter("int[]@X...a[]");
+
+        assertThat(p.getVarArgsAnnotations()).containsExactly(new MarkerAnnotationExpr(parseName("X")));
+        assertEquals("int[][]@X ... a", p.toString());
+        assertEquals("int[][]@X... a", ConcreteSyntaxModel.genericPrettyPrint(p));
+    }
+}