1 files changed, 54 insertions, 23 deletions
diff --git a/java/java-tests/testSrc/com/intellij/codeInsight/psi/AnnotatedTypeTest.groovy b/java/java-tests/testSrc/com/intellij/codeInsight/psi/AnnotatedTypeTest.groovy
index f186f9e8f5c8..6373bc3ce307 100644
--- a/java/java-tests/testSrc/com/intellij/codeInsight/psi/AnnotatedTypeTest.groovy
+++ b/java/java-tests/testSrc/com/intellij/codeInsight/psi/AnnotatedTypeTest.groovy
@@ -1,5 +1,5 @@
 /*
- * Copyright 2000-2013 JetBrains s.r.o.
+ * Copyright 2000-2014 JetBrains s.r.o.
  *
  * Licensed under the Apache License, Version 2.0 (the "License");
  * you may not use this file except in compliance with the License.
@@ -15,15 +15,22 @@
  */
 package com.intellij.codeInsight.psi
 
-import com.intellij.psi.PsiElement
-import com.intellij.psi.PsiFile
+import com.intellij.pom.java.LanguageLevel
+import com.intellij.psi.*
+import com.intellij.psi.impl.source.PsiImmediateClassType
 import com.intellij.testFramework.LightIdeaTestCase
 
-@SuppressWarnings(["GrUnresolvedAccess", "GroovyAssignabilityCheck"])
+@SuppressWarnings("GroovyAssignabilityCheck")
 class AnnotatedTypeTest extends LightIdeaTestCase {
+  private PsiFile context
+  private PsiElementFactory factory
+
+  public void setUp() throws Exception {
+    super.setUp()
+    factory = javaFacade.elementFactory
+    context = createFile("typeCompositionTest.java", """
+package pkg;
 
-  public void testTypeComposition() {
-    PsiFile context = createFile("typeCompositionTest.java", """
 import java.lang.annotation.*;
 import static java.lang.annotation.ElementType.*;
 
@@ -33,31 +40,55 @@ import static java.lang.annotation.ElementType.*;
 class E1 extends Exception { }
 class E2 extends Exception { }
 """)
-    PsiElement psi
+  }
+
+  public void testPrimitiveArrayType() {
+    doTest("@A @TA(1) int @TA(2) [] a", "@pkg.TA(1) int @pkg.TA(2) []", "int[]")
+  }
 
-    psi = javaFacade.elementFactory.createStatementFromText("@A @TA(1) int @TA(2) [] a", context)
-    assertEquals("@TA(1) int @TA(2) []", psi.declaredElements[0].type.presentableText)
+  public void testEllipsisType() {
+    def psi = factory.createParameterFromText("@TA int @TA ... p", context)
+    assertTypeText(psi.type, "@pkg.TA int @pkg.TA ...", "int...")
+  }
 
-    psi = javaFacade.elementFactory.createStatementFromText("try { } catch (@A @TA(1) E1 | @TA(2) E2 e) { }", context)
-    assertEquals("@TA(1) E1 | @TA(2) E2", psi.catchBlockParameters[0].type.presentableText)
+  public void testClassReferenceType() {
+    doTest("@A @TA(1) String s", "java.lang.@pkg.TA(1) String", "java.lang.String")
+    doTest("@A java.lang.@TA(1) String s", "java.lang.@pkg.TA(1) String", "java.lang.String")
+  }
 
-    psi = javaFacade.elementFactory.createStatementFromText("@A @TA(1) String @TA(2) [] f @TA(3) []", context)
-    assertEquals("@TA(1) String @TA(2) [] @TA(3) []", psi.declaredElements[0].type.presentableText)
+  public void testCStyleArrayType() {
+    doTest("@A @TA(1) String @TA(2) [] f @TA(3) []", "java.lang.@pkg.TA(1) String @pkg.TA(2) [] @pkg.TA(3) []", "java.lang.String[][]")
+  }
 
-    psi = javaFacade.elementFactory.createStatementFromText("Class<@TA(1) ?> c", context)
-    assertEquals("Class<@TA(1) ?>", psi.declaredElements[0].type.presentableText)
+  public void testWildcardType() {
+    doTest("Class<@TA(1) ?> c", "java.lang.Class<@pkg.TA(1) ?>", "java.lang.Class<?>")
+  }
 
-    psi = javaFacade.elementFactory.createStatementFromText("Class<@TA String> cs = new Class<>()", context)
-    assertEquals("Class<@TA String>", psi.declaredElements[0].initializer.type.presentableText)
+  public void testDisjunctionType() {
+    def psi = factory.createStatementFromText("try { } catch (@A @TA(1) E1 | @TA(2) E2 e) { }", context)
+    assertTypeText(psi.catchBlockParameters[0].type, "pkg.@pkg.TA(1) E1 | pkg.@pkg.TA(2) E2", "pkg.E1 | pkg.E2")
+  }
 
-    psi = javaFacade.elementFactory.createStatementFromText("@A @TA(1) String s", context)
-    assertEquals("@TA(1) String", psi.declaredElements[0].type.presentableText)
+  public void testDiamondType() {
+    def psi = factory.createStatementFromText("Class<@TA String> cs = new Class<>()", context)
+    assertTypeText(psi.declaredElements[0].initializer.type, "java.lang.Class<java.lang.@pkg.TA String>", "java.lang.Class<java.lang.String>")
+  }
 
-    psi = javaFacade.elementFactory.createStatementFromText("@A java.lang.@TA(1) String s", context)
-    assertEquals("@TA(1) String", psi.declaredElements[0].type.presentableText)
+  public void testImmediateClassType() {
+    def aClass = javaFacade.findClass(CommonClassNames.JAVA_LANG_OBJECT)
+    def statement = factory.createStatementFromText("@TA int x", context)
+    def annotations = statement.declaredElements[0].modifierList.annotations
+    def type = new PsiImmediateClassType(aClass, PsiSubstitutor.EMPTY, LanguageLevel.JDK_1_8, annotations)
+    assertTypeText(type, "java.lang.@pkg.TA Object", CommonClassNames.JAVA_LANG_OBJECT)
+  }
 
-    psi = javaFacade.elementFactory.createStatementFromText("Collection<? extends> s", context)
-    assertEquals("Collection<?>", psi.declaredElements[0].type.presentableText)
+  private void doTest(String text, String annotated, String canonical) {
+    def psi = factory.createStatementFromText(text, context)
+    assertTypeText(psi.declaredElements[0].type, annotated, canonical)
   }
 
+  private static void assertTypeText(PsiType type, String annotated, String canonical) {
+    assert type.getCanonicalText(true) == annotated
+    assert type.getCanonicalText(false) == canonical
+  }
 }