java/java-tests/testSrc/com/intellij/psi/ClsRepositoryUseTest.java

/*
 * 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.
 * You may obtain a copy of the License at
 *
 * http://www.apache.org/licenses/LICENSE-2.0
 *
 * Unless required by applicable law or agreed to in writing, software
 * distributed under the License is distributed on an "AS IS" BASIS,
 * WITHOUT WARRANTIES OR CONDITIONS OF ANY KIND, either express or implied.
 * See the License for the specific language governing permissions and
 * limitations under the License.
 */
package com.intellij.psi;

import com.intellij.ide.highlighter.JavaFileType;
import com.intellij.openapi.application.ApplicationManager;
import com.intellij.openapi.application.ex.PathManagerEx;
import com.intellij.openapi.roots.ModuleRootModificationUtil;
import com.intellij.openapi.roots.OrderRootType;
import com.intellij.openapi.util.io.FileUtil;
import com.intellij.openapi.vfs.LocalFileSystem;
import com.intellij.openapi.vfs.VirtualFile;
import com.intellij.openapi.vfs.VirtualFileFilter;
import com.intellij.psi.impl.compiled.ClsParameterImpl;
import com.intellij.psi.impl.java.stubs.PsiMethodStub;
import com.intellij.psi.search.GlobalSearchScope;
import com.intellij.psi.util.PsiUtil;
import com.intellij.testFramework.IdeaTestUtil;
import com.intellij.testFramework.PlatformTestCase;
import com.intellij.testFramework.PsiTestCase;
import com.intellij.testFramework.PsiTestUtil;

import java.io.File;

@PlatformTestCase.WrapInCommand
public class ClsRepositoryUseTest extends PsiTestCase {
  private static final String TEST_ROOT = PathManagerEx.getTestDataPath() + "/psi/repositoryUse/cls";

  private GlobalSearchScope RESOLVE_SCOPE;

  @Override
  protected void setUp() throws Exception {
    super.setUp();

    ApplicationManager.getApplication().runWriteAction(
      new Runnable() {
        @Override
        public void run() {
          VirtualFile vDir = getRootFile();
          PsiTestUtil.removeAllRoots(myModule, IdeaTestUtil.getMockJdk17());
          addLibraryToRoots(vDir, OrderRootType.CLASSES);
        }
      }
    );

    RESOLVE_SCOPE = GlobalSearchScope.moduleWithDependenciesAndLibrariesScope(myModule);
  }

  @Override
  protected void tearDown() throws Exception {
    RESOLVE_SCOPE = null;
    super.tearDown();
  }

  public void testClassFileUpdate() throws Exception {
    final File classes = createTempDir("classes", false);

    final File com = new File(classes, "com");
    FileUtil.ensureExists(com);

    File dataPath = new File(PathManagerEx.getTestDataPath() + "/psi/cls");

    final File target = new File(com, "TestClass.class");
    FileUtil.copy(new File(dataPath, "1/TestClass.class"), target);
    assertTrue(target.setLastModified(System.currentTimeMillis()));

    ApplicationManager.getApplication().runWriteAction(
      new Runnable() {
        @Override
        public void run() {
          VirtualFile vDir = LocalFileSystem.getInstance().refreshAndFindFileByIoFile(classes);
          assertNotNull(vDir);
          addLibraryToRoots(vDir, OrderRootType.CLASSES);
        }
      }
    );

    PsiClass psiClass = myJavaFacade.findClass("com.TestClass", GlobalSearchScope.allScope(myProject));
    assert psiClass != null;
    PsiJavaFile psiFile = (PsiJavaFile)psiClass.getContainingFile();
    final VirtualFile vFile = psiFile.getVirtualFile();

    assertNotNull(psiClass);
    assertTrue(psiClass.isValid());
    assertTrue(psiFile.isValid());

    assertEquals(1, psiFile.getClasses().length);
    assertSame(psiClass, psiFile.getClasses()[0]);

    assertEquals(2, psiClass.getFields().length);
    assertEquals("field11", psiClass.getFields()[0].getName());
    assertEquals("field12", psiClass.getFields()[1].getName());

    assertEquals(2, psiClass.getMethods().length);
    assertEquals("TestClass", psiClass.getMethods()[0].getName());
    assertEquals("method1", psiClass.getMethods()[1].getName());

    FileUtil.copy(new File(dataPath, "2/TestClass.class"), target);
    assertTrue(target.setLastModified(System.currentTimeMillis() + 5000));

    assert vFile != null;
    ApplicationManager.getApplication().runWriteAction(
      new Runnable() {
        @Override
        public void run() {
          vFile.refresh(false, false);
        }
      }
    );

    assertTrue(psiFile.isValid());
    PsiClass oldClass = psiClass;
    psiClass = myJavaFacade.findClass("com.TestClass", GlobalSearchScope.allScope(myProject));
    assertNotSame(oldClass, psiClass);
    assertFalse(oldClass.isValid());

    assertNotNull(psiClass);
    assertEquals(1, psiFile.getClasses().length);
    assertSame(psiClass, psiFile.getClasses()[0]);

    assertTrue(psiClass.isValid());
    assertEquals(1, psiClass.getFields().length);
    assertEquals("field2", psiClass.getFields()[0].getName());

    assertEquals(2, psiClass.getMethods().length);
    assertEquals("TestClass", psiClass.getMethods()[0].getName());
    assertEquals("method2", psiClass.getMethods()[1].getName());
  }

  private static VirtualFile getRootFile() {
    final String path = TEST_ROOT.replace(File.separatorChar, '/');
    final VirtualFile vDir = LocalFileSystem.getInstance().findFileByPath(path);
    assert vDir != null : path;
    return vDir;
  }

  public void testGetClasses() {
    final VirtualFile rootFile = getRootFile();
    final VirtualFile pack = rootFile.findChild("pack");
    assert pack != null;
    VirtualFile child = pack.findChild("MyClass.class");
    assertNotNull(child);
    PsiJavaFile file = (PsiJavaFile)myPsiManager.findFile(child);
    checkValid(file);
    assert file != null;
    PsiClass[] classes = file.getClasses();
    assertTrue(classes.length == 1);
    PsiClass aClass = classes[0];
    checkValid(aClass);
    assertEquals(file, aClass.getParent());
  }

  public void testGetClassName() {
    final VirtualFile rootFile = getRootFile();
    final VirtualFile pack = rootFile.findChild("pack");
    assert pack != null;
    VirtualFile child = pack.findChild("MyClass.class");
    assertNotNull(child);
    PsiJavaFile file = (PsiJavaFile)myPsiManager.findFile(child);
    assert file != null;
    PsiClass[] classes = file.getClasses();
    assertTrue(classes.length == 1);

    PsiClass aClass = classes[0];
    checkValid(aClass);
    assertEquals("MyClass", aClass.getName());
  }

  public void testGetClassQName() {
    final VirtualFile rootFile = getRootFile();
    final VirtualFile pack = rootFile.findChild("pack");
    assert pack != null;
    VirtualFile child = pack.findChild("MyClass.class");
    assertNotNull(child);
    PsiJavaFile file = (PsiJavaFile)myPsiManager.findFile(child);
    assert file != null;
    PsiClass[] classes = file.getClasses();
    assertTrue(classes.length == 1);

    PsiClass aClass = classes[0];
    checkValid(aClass);
    assertEquals("pack.MyClass", aClass.getQualifiedName());
  }

  public void testGetContainingFile() {
    final VirtualFile rootFile = getRootFile();
    final VirtualFile pack = rootFile.findChild("pack");
    assert pack != null;
    VirtualFile child = pack.findChild("MyClass.class");
    assertNotNull(child);
    PsiJavaFile file = (PsiJavaFile)myPsiManager.findFile(child);
    assert file != null;
    PsiClass[] classes = file.getClasses();
    assertTrue(classes.length == 1);

    PsiClass aClass = classes[0];
    checkValid(aClass);
    assertEquals(file, aClass.getContainingFile());
  }

  public void testFindClass() {
    getJavaFacade().setAssertOnFileLoadingFilter(VirtualFileFilter.ALL, myTestRootDisposable);

    PsiClass aClass = myJavaFacade.findClass("pack.MyClass", GlobalSearchScope.allScope(myProject));
    assertNotNull(aClass);
    checkValid(aClass);
  }

  public void testIsInterface() {
    PsiClass aClass = myJavaFacade.findClass("pack.MyClass", GlobalSearchScope.allScope(myProject));
    assert aClass != null;
    checkValid(aClass);
    assertTrue(!aClass.isInterface());
  }

  private static void checkValid(final PsiElement elt) {
    assertTrue(elt.isValid());
  }

  public void testPackageName() {
    PsiClass aClass = myJavaFacade.findClass("pack.MyClass", GlobalSearchScope.allScope(myProject));
    assert aClass != null;
    checkValid(aClass);
    String packageName = ((PsiJavaFile)aClass.getContainingFile()).getPackageName();
    assertEquals("pack", packageName);
  }

  public void testGetFields() {
    PsiClass aClass = myJavaFacade.findClass("pack.MyClass", GlobalSearchScope.allScope(myProject));
    assert aClass != null;
    checkValid(aClass);
    PsiField[] fields = aClass.getFields();
    assertEquals(2, fields.length);
    assertEquals(aClass, fields[0].getParent());
  }

  public void testGetMethods() {
    PsiClass aClass = myJavaFacade.findClass("pack.MyClass", GlobalSearchScope.allScope(myProject));
    assert aClass != null;
    checkValid(aClass);
    PsiMethod[] methods = aClass.getMethods();
    assertEquals(3, methods.length);
    assertEquals(aClass, methods[0].getParent());
  }

  public void testGetInnerClasses() {
    PsiClass aClass = myJavaFacade.findClass("pack.MyClass", GlobalSearchScope.allScope(myProject));
    assert aClass != null;
    checkValid(aClass);
    PsiClass[] inners = aClass.getInnerClasses();
    assertEquals(1, inners.length);
    assertEquals(aClass, inners[0].getParent());
  }

  public void testModifierList() throws Exception {
    PsiClass aClass = myJavaFacade.findClass("pack.MyClass", GlobalSearchScope.allScope(myProject));
    assert aClass != null;
    checkValid(aClass);

    PsiModifierList modifierList = aClass.getModifierList();
    assert modifierList != null : aClass;
    assertTrue(modifierList.hasModifierProperty(PsiModifier.PUBLIC));
    assertFalse(modifierList.hasModifierProperty(PsiModifier.STATIC));
    assertEquals(modifierList.getParent(), aClass);

    PsiField field = aClass.getFields()[0];
    modifierList = field.getModifierList();
    assert modifierList != null : field;
    assertTrue(modifierList.hasModifierProperty(PsiModifier.PACKAGE_LOCAL));
    assertEquals(modifierList.getParent(), field);

    PsiMethod method = aClass.getMethods()[0];
    modifierList = method.getModifierList();
    assertTrue(modifierList.hasModifierProperty(PsiModifier.PACKAGE_LOCAL));
    assertEquals(modifierList.getParent(), method);
  }

  public void testGetFieldName() {
    PsiClass aClass = myJavaFacade.findClass("pack.MyClass", GlobalSearchScope.allScope(myProject));
    assert aClass != null;
    checkValid(aClass);
    assertEquals("field1", aClass.getFields()[0].getName());
  }

  public void testGetMethodName() {
    PsiClass aClass = myJavaFacade.findClass("pack.MyClass", GlobalSearchScope.allScope(myProject));
    assert aClass != null;
    checkValid(aClass);
    assertEquals("method1", aClass.getMethods()[0].getName());
  }

  public void testFindFieldByName() {
    PsiClass aClass = myJavaFacade.findClass("pack.MyClass", GlobalSearchScope.allScope(myProject));
    assert aClass != null;
    checkValid(aClass);
    PsiField field = aClass.findFieldByName("field1", false);
    assertNotNull(field);
  }

  public void testIsDeprecated() {
    PsiClass aClass = myJavaFacade.findClass("pack.MyClass", GlobalSearchScope.allScope(myProject));
    assert aClass != null;
    checkValid(aClass);
    assertTrue(!aClass.isDeprecated());

    PsiField field = aClass.findFieldByName("field1", false);
    assert field != null : aClass;
    assertTrue(field.isDeprecated());
  }

  public void testFieldType() throws Exception {
    PsiClass aClass = myJavaFacade.findClass("pack.MyClass", GlobalSearchScope.allScope(myProject));
    assert aClass != null;
    checkValid(aClass);

    PsiField field1 = aClass.getFields()[0];
    PsiType type1 = field1.getType();

    PsiField field2 = aClass.getFields()[1];
    PsiType type2 = field2.getType();

    assertEquals(PsiType.INT, type1);
    assertTrue(type2.equalsToText("java.lang.Object[]"));

    assertEquals("int", type1.getPresentableText());
    assertEquals("Object[]", type2.getPresentableText());

    assertTrue(type1 instanceof PsiPrimitiveType);
    assertTrue(!(type2 instanceof PsiPrimitiveType));
    assertTrue(type2 instanceof PsiArrayType);
  }

  public void testMethodType() throws Exception {
    PsiClass aClass = myJavaFacade.findClass("pack.MyClass", GlobalSearchScope.allScope(myProject));
    assert aClass != null;
    checkValid(aClass);

    PsiMethod method1 = aClass.getMethods()[0];
    PsiTypeElement type1 = method1.getReturnTypeElement();
    assert type1 != null : method1;
    assertEquals(method1, type1.getParent());

    assertEquals("void", type1.getText());
    assertTrue(type1.getType() instanceof PsiPrimitiveType);

    PsiMethod method3 = aClass.getMethods()[2];
    assertNull(method3.getReturnType());
  }

  public void testIsConstructor() throws Exception {
    PsiClass aClass = myJavaFacade.findClass("pack.MyClass", GlobalSearchScope.allScope(myProject));
    assert aClass != null;
    checkValid(aClass);

    PsiMethod method1 = aClass.getMethods()[0];
    assertFalse(method1.isConstructor());

    PsiMethod method3 = aClass.getMethods()[2];
    assertTrue(method3.isConstructor());
  }

  public void testComponentType() throws Exception {
    PsiClass aClass = myJavaFacade.findClass("pack.MyClass", GlobalSearchScope.allScope(myProject));
    assert aClass != null;
    checkValid(aClass);

    PsiField field = aClass.getFields()[1];
    PsiType type = field.getType();
    assertTrue(type instanceof PsiArrayType);
    PsiType componentType = ((PsiArrayType)type).getComponentType();

    assertTrue(componentType.equalsToText(CommonClassNames.JAVA_LANG_OBJECT));
    assertEquals("Object", componentType.getPresentableText());
    assertFalse(componentType instanceof PsiPrimitiveType);
    assertFalse(componentType instanceof PsiArrayType);
  }

  public void testTypeReference() throws Exception {
    PsiClass aClass = myJavaFacade.findClass("pack.MyClass", GlobalSearchScope.allScope(myProject));
    assert aClass != null;
    checkValid(aClass);

    PsiField field1 = aClass.getFields()[0];
    PsiType type1 = field1.getType();
    assertNull(PsiUtil.resolveClassInType(type1));

    PsiField field2 = aClass.getFields()[1];
    PsiType type2 = ((PsiArrayType)field2.getType()).getComponentType();
    assertTrue(type2 instanceof PsiClassType);

    assertTrue(type2.equalsToText(CommonClassNames.JAVA_LANG_OBJECT));
    assertEquals("Object", type2.getPresentableText());
  }

  public void testResolveTypeReference() throws Exception {
    PsiClass aClass = myJavaFacade.findClass("pack.MyClass", GlobalSearchScope.allScope(myProject));
    assert aClass != null;
    checkValid(aClass);

    PsiType type1 = aClass.getFields()[1].getType();
    PsiElement target1 = PsiUtil.resolveClassInType(type1);
    assertNotNull(target1);
    PsiClass objectClass = myJavaFacade.findClasses(CommonClassNames.JAVA_LANG_OBJECT, RESOLVE_SCOPE)[1];
    assertEquals(objectClass, target1);
  }

  public void testInitializer() throws Exception {
    PsiClass aClass = myJavaFacade.findClass("pack.MyClass", GlobalSearchScope.allScope(myProject));
    assert aClass != null;
    checkValid(aClass);

    PsiField field1 = aClass.getFields()[0];
    assertTrue(field1.hasInitializer());
    PsiLiteralExpression initializer = (PsiLiteralExpression)field1.getInitializer();
    assert initializer != null : field1;
    assertEquals("123", initializer.getText());
    assertEquals(new Integer(123), initializer.getValue());
    assertEquals(PsiType.INT, initializer.getType());

    PsiField field2 = aClass.getFields()[1];
    assertFalse(field2.hasInitializer());
    assertNull(field2.getInitializer());
  }

  public void testExtendsList() throws Exception {
    PsiClass aClass = myJavaFacade.findClass("pack.MyClass", GlobalSearchScope.allScope(myProject));
    assert aClass != null;
    checkValid(aClass);

    PsiReferenceList list = aClass.getExtendsList();
    assert list != null : aClass;
    PsiClassType[] refs = list.getReferencedTypes();
    assertEquals(1, refs.length);
    assertEquals("ArrayList", refs[0].getPresentableText());
    assertEquals("java.util.ArrayList", refs[0].getCanonicalText());
  }

  public void testImplementsList() throws Exception {
    PsiClass aClass = myJavaFacade.findClass("pack.MyClass", GlobalSearchScope.allScope(myProject));
    assert aClass != null;
    checkValid(aClass);

    PsiReferenceList list = aClass.getImplementsList();
    assert list != null : aClass;
    PsiClassType[] refs = list.getReferencedTypes();
    assertEquals(1, refs.length);
    assertEquals("Cloneable", refs[0].getPresentableText());
    assertEquals("java.lang.Cloneable", refs[0].getCanonicalText());
  }

  public void testThrowsList() throws Exception {
    PsiClass aClass = myJavaFacade.findClass("pack.MyClass", GlobalSearchScope.allScope(myProject));
    assert aClass != null;
    checkValid(aClass);

    PsiReferenceList list = aClass.getMethods()[0].getThrowsList();

    PsiClassType[] refs = list.getReferencedTypes();
    assertEquals(2, refs.length);
    assertEquals("Exception", refs[0].getPresentableText());
    assertEquals("IOException", refs[1].getPresentableText());
    assertEquals("java.lang.Exception", refs[0].getCanonicalText());
    assertEquals("java.io.IOException", refs[1].getCanonicalText());
  }

  public void testParameters() throws Exception {
    PsiClass aClass = myJavaFacade.findClass("pack.MyClass", GlobalSearchScope.allScope(myProject));
    assert aClass != null;
    checkValid(aClass);

    PsiParameterList list = aClass.getMethods()[0].getParameterList();

    PsiParameter[] parameters = list.getParameters();
    assertEquals(2, parameters.length);

    PsiType type1 = parameters[0].getType();
    assertEquals("int[]", type1.getPresentableText());
    assertTrue(type1.equalsToText("int[]"));
    assertTrue(type1 instanceof PsiArrayType);
    assertNull(PsiUtil.resolveClassInType(type1));

    PsiType type2 = parameters[1].getType();
    assertEquals("Object", type2.getPresentableText());
    assertTrue(type2.equalsToText(CommonClassNames.JAVA_LANG_OBJECT));
    assertFalse(type2 instanceof PsiArrayType);
    assertFalse(type2 instanceof PsiPrimitiveType);
    PsiClass target2 = PsiUtil.resolveClassInType(type2);
    assertNotNull(target2);
    PsiClass objectClass = myJavaFacade.findClasses(CommonClassNames.JAVA_LANG_OBJECT, RESOLVE_SCOPE)[1];
    assertEquals(objectClass, target2);

    assertNotNull(parameters[0].getModifierList());
    assertNotNull(parameters[1].getModifierList());

    assertTrue(((ClsParameterImpl)parameters[0]).isAutoGeneratedName());
    assertTrue(((ClsParameterImpl)parameters[1]).isAutoGeneratedName());
    assertEquals("ints", parameters[0].getName());
    assertEquals("o", parameters[1].getName());
  }

  public void testGenericClass() throws Exception {
    disableJdk();

    PsiClass map = myJavaFacade.findClass("java.util.HashMap", RESOLVE_SCOPE);
    assert map != null;
    PsiMethod entrySet = map.findMethodsByName("entrySet", false)[0];
    PsiClassType ret = (PsiClassType)entrySet.getReturnType();
    assert ret != null : entrySet;
    final PsiClassType.ClassResolveResult setResolveResult = ret.resolveGenerics();
    final PsiClass setResolveResultElement = setResolveResult.getElement();
    assert setResolveResultElement != null : setResolveResult;
    assertEquals(CommonClassNames.JAVA_UTIL_SET, setResolveResultElement.getQualifiedName());
    final PsiTypeParameter typeParameter = setResolveResultElement.getTypeParameters()[0];

    final PsiType substitutedResult = setResolveResult.getSubstitutor().substitute(typeParameter);
    assertTrue(substitutedResult instanceof PsiWildcardType);
    assertTrue(((PsiWildcardType)substitutedResult).isExtends());
    PsiClassType setType = (PsiClassType)((PsiWildcardType)substitutedResult).getBound();
    assert setType != null;
    final PsiClassType.ClassResolveResult setTypeResolveResult = setType.resolveGenerics();
    final PsiClass setTypeResolveResultElement = setTypeResolveResult.getElement();
    assert setTypeResolveResultElement != null : setTypeResolveResult;
    assertEquals("java.util.Map.Entry", setTypeResolveResultElement.getQualifiedName());
    final PsiTypeParameter[] typeParameters = setTypeResolveResultElement.getTypeParameters();
    assertEquals(2, typeParameters.length);
    PsiType[] mapParams = {
      setTypeResolveResult.getSubstitutor().substitute(typeParameters[0]),
      setTypeResolveResult.getSubstitutor().substitute(typeParameters[1])
    };
    assertEquals(2, mapParams.length);
    assertEquals("K", mapParams[0].getCanonicalText());
    assertTrue(((PsiClassType)mapParams[0]).resolve() instanceof PsiTypeParameter);
    assertEquals("V", mapParams[1].getCanonicalText());
    assertTrue(((PsiClassType)mapParams[1]).resolve() instanceof PsiTypeParameter);
  }

  private void disableJdk() {
    ModuleRootModificationUtil.setModuleSdk(myModule, null);
  }

  public void testGenericReturnType() throws Exception {
    disableJdk();

    final PsiClass map = myJavaFacade.findClass(CommonClassNames.JAVA_UTIL_MAP, RESOLVE_SCOPE);
    assert map != null;
    final PsiElementFactory factory = myJavaFacade.getElementFactory();
    final PsiClassType typeMapStringToInteger =
      (PsiClassType)factory.createTypeFromText("java.util.Map <java.lang.String,java.lang.Integer>", null);
    final PsiClassType.ClassResolveResult mapResolveResult = typeMapStringToInteger.resolveGenerics();
    final PsiClass mapResolveResultElement = mapResolveResult.getElement();
    assert mapResolveResultElement != null : typeMapStringToInteger;
    assertTrue(mapResolveResultElement.equals(map));

    final PsiMethod entrySetMethod = map.findMethodsByName("entrySet", false)[0];
    final PsiType entrySetReturnType = entrySetMethod.getReturnType();
    assert entrySetReturnType != null : entrySetMethod;
    assertEquals("java.util.Set<? extends java.util.Map.Entry<K,V>>", entrySetReturnType.getCanonicalText());
    final PsiSubstitutor substitutor = ((PsiClassType)entrySetReturnType).resolveGenerics().getSubstitutor();
    assertEquals("E of java.util.Set -> ? extends java.util.Map.Entry<K,V>\n", substitutor.toString());
    final PsiType typeSetOfEntriesOfStringAndInteger =
      factory.createTypeFromText("java.util.Set<? extends java.util.Map.Entry<java.lang.String,java.lang.Integer>>", null);
    final PsiType substitutedEntrySetReturnType = mapResolveResult.getSubstitutor().substitute(entrySetReturnType);
    assertTrue(typeSetOfEntriesOfStringAndInteger.equals(substitutedEntrySetReturnType));
    assertTrue(typeSetOfEntriesOfStringAndInteger.isAssignableFrom(substitutedEntrySetReturnType));
  }

  public void testGenericInheritance() throws Exception {
    final String text = "import java.util.*;\n" +
                        "class Dummy {\n" +
                        "  { Map<Integer, Integer> list = new HashMap<Integer, Integer>();}\n" +
                        "}";
    PsiJavaFile file = (PsiJavaFile)PsiFileFactory.getInstance(getProject()).createFileFromText("Dummy.java", JavaFileType.INSTANCE, text);

    PsiDeclarationStatement decl = (PsiDeclarationStatement)file.getClasses()[0].getInitializers()[0].getBody().getStatements()[0];
    PsiVariable list = (PsiVariable)decl.getDeclaredElements()[0];
    final PsiExpression initializer = list.getInitializer();
    assert initializer != null : list;
    final PsiType type = initializer.getType();
    assert type != null : initializer;
    assertTrue(list.getType().isAssignableFrom(type));
  }

  public void testSimplerGenericInheritance() throws Exception {
    PsiElementFactory factory = myJavaFacade.getElementFactory();
    PsiClass map = myJavaFacade.findClass(CommonClassNames.JAVA_UTIL_MAP, RESOLVE_SCOPE);
    PsiClass hashMap = myJavaFacade.findClass("java.util.HashMap", RESOLVE_SCOPE);
    assert map != null && hashMap != null;
    assertTrue(factory.createType(map).isAssignableFrom(factory.createType(hashMap)));
  }

  public void testAnnotations() throws Exception {
    PsiClass aClass = myJavaFacade.findClass("pack.Annotated", GlobalSearchScope.allScope(myProject));
    assert aClass != null;
    checkValid(aClass);

    PsiModifierList modifierList = aClass.getModifierList();
    assert modifierList != null : aClass;
    PsiAnnotation[] annotations = modifierList.getAnnotations();
    assertTrue(annotations.length == 1);
    assertTrue(annotations[0].getText().equals("@pack.Annotation"));

    PsiMethod[] methods = aClass.findMethodsByName("foo", false);
    assertTrue(methods.length == 1);
    annotations = methods[0].getModifierList().getAnnotations();
    assertTrue(annotations.length == 1);
    assertTrue(annotations[0].getText().equals("@pack.Annotation"));

    PsiParameter[] params = methods[0].getParameterList().getParameters();
    assertTrue(params.length == 1);
    modifierList = params[0].getModifierList();
    assert modifierList != null : params[0];
    annotations = modifierList.getAnnotations();
    assertTrue(annotations.length == 1);
    assertTrue(annotations[0].getText().equals("@pack.Annotation"));

    PsiField[] fields = aClass.getFields();
    assertTrue(fields.length == 1);
    modifierList = fields[0].getModifierList();
    assert modifierList != null : fields[0];
    annotations = modifierList.getAnnotations();
    assertTrue(annotations.length == 1);
    assertTrue(annotations[0].getText().equals("@pack.Annotation"));
  }

  public void testAnnotationMethodDefault() throws Exception {
    PsiClass aClass = myJavaFacade.findClass("pack.Annotation", GlobalSearchScope.allScope(myProject));
    assert aClass != null;
    checkValid(aClass);

    PsiMethod[] methods = aClass.findMethodsByName("value", false);
    assertTrue(methods.length == 1 && methods[0] instanceof PsiAnnotationMethod);
    PsiAnnotationMemberValue defaultValue = ((PsiAnnotationMethod)methods[0]).getDefaultValue();
    assertTrue(defaultValue != null);
  }

  public void testIndeterminateInAnnotationMethodDefault() throws Exception {
    final PsiClass aClass = myJavaFacade.findClass("pack.Annotation2", GlobalSearchScope.allScope(myProject));
    assert aClass != null;
    checkValid(aClass);

    for (PsiMethod method : aClass.getMethods()) {
      assert method instanceof PsiAnnotationMethod : method;
      try {
        final PsiAnnotationMemberValue defaultValue = ((PsiAnnotationMethod)method).getDefaultValue();
        assert defaultValue instanceof PsiBinaryExpression : defaultValue;
        final PsiPrimitiveType type = method.getName().startsWith("f") ? PsiType.FLOAT : PsiType.DOUBLE;
        assertEquals(type, ((PsiBinaryExpression)defaultValue).getType());
      }
      catch (Exception e) {
        final String valueText = ((PsiMethodStub)((StubBasedPsiElement)method).getStub()).getDefaultValueText();
        fail("Unable to compute default value of method " + method + " from text '" + valueText + "': " + e.getMessage());
      }
    }
  }

  public void testEnum() throws Exception {
    PsiClass aClass = myJavaFacade.findClass("pack.MyEnum", GlobalSearchScope.allScope(myProject));
    assert aClass != null;
    checkValid(aClass);

    assertTrue(aClass.isEnum());
    PsiField[] fields = aClass.getFields();
    PsiClassType type = myJavaFacade.getElementFactory().createType(aClass);
    checkEnumConstant("RED", fields[0], type);
    checkEnumConstant("GREEN", fields[1], type);
    checkEnumConstant("BLUE", fields[2], type);
  }

  public void testVariance() throws Exception {
    final PsiClass aClass = myJavaFacade.findClass("pack.Variance", RESOLVE_SCOPE);
    assert aClass != null;
    checkValid(aClass);

    final PsiMethod[] methodsByName = aClass.findMethodsByName("method", false);
    assertEquals(1, methodsByName.length);
    final PsiMethod methodsWithReturnType = methodsByName[0];
    final PsiType returnType = methodsWithReturnType.getReturnType();
    assert returnType != null : methodsWithReturnType;
    assertEquals("pack.Parametrized<? extends T>", returnType.getCanonicalText());
  }

  private static void checkEnumConstant(String name, PsiField field, PsiClassType type) {
    assertEquals(name, field.getName());
    assertTrue(field instanceof PsiEnumConstant);
    assertEquals(type, field.getType());
  }

  public void testInvariantParsing() throws Exception {
    final PsiClass collection = myJavaFacade.findClass("pack.Variance", RESOLVE_SCOPE);
    assertNotNull(collection);
    final PsiMethod[] methods = collection.findMethodsByName("removeAll", false);
    assertEquals(1, methods.length);
    final PsiParameter[] parameters = methods[0].getParameterList().getParameters();
    assertEquals(1, parameters.length);
    final PsiType parameterType = parameters[0].getType();
    assertTrue(parameterType instanceof PsiClassType);
    final PsiClassType psiClassType = ((PsiClassType)parameterType);
    final PsiClassType.ClassResolveResult resolveResult = psiClassType.resolveGenerics();
    final PsiClass resolveResultElement = resolveResult.getElement();
    assert resolveResultElement != null : psiClassType;
    final PsiTypeParameter[] typeParameters = resolveResultElement.getTypeParameters();
    assertEquals(1, typeParameters.length);
    final PsiType substitution = resolveResult.getSubstitutor().substitute(typeParameters[0]);
    assertTrue(substitution instanceof PsiWildcardType);
    assertEquals(PsiWildcardType.createUnbounded(myPsiManager), substitution);
  }

  public void testInvariantParsing2() throws Exception {
    disableJdk();
    final PsiClass collection = myJavaFacade.findClass("java.util.Collection", RESOLVE_SCOPE);
    assertNotNull(collection);
    final PsiMethod[] methods = collection.findMethodsByName("removeAll", false);
    assertEquals(1, methods.length);
    final PsiParameter[] parameters = methods[0].getParameterList().getParameters();
    assertEquals(1, parameters.length);
    final PsiType parameterType = parameters[0].getType();
    assertTrue(parameterType instanceof PsiClassType);
    final PsiClassType psiClassType = ((PsiClassType)parameterType);
    final PsiClassType.ClassResolveResult resolveResult = psiClassType.resolveGenerics();
    final PsiClass resolveResultElement = resolveResult.getElement();
    assert resolveResultElement != null : psiClassType;
    final PsiTypeParameter[] typeParameters = resolveResultElement.getTypeParameters();
    assertEquals(1, typeParameters.length);
    final PsiType substitution = resolveResult.getSubstitutor().substitute(typeParameters[0]);
    assertTrue(substitution instanceof PsiWildcardType);
    assertEquals(PsiWildcardType.createUnbounded(myPsiManager), substitution);
  }

  @SuppressWarnings("ConstantConditions")
  public void testModifiers() throws Exception {
    PsiClass psiClass = myJavaFacade.findClass("pack.Modifiers", RESOLVE_SCOPE);
    assertNotNull(psiClass);

    PsiField f1 = psiClass.findFieldByName("f1", false);
    assertEquals("private transient", f1.getModifierList().getText());
    PsiField f2 = psiClass.findFieldByName("f2", false);
    assertEquals("private volatile", f2.getModifierList().getText());
    PsiMethod init = psiClass.findMethodsByName("Modifiers", false)[0];
    assertEquals("public", init.getModifierList().getText());
    PsiMethod m1 = psiClass.findMethodsByName("m1", false)[0];
    assertEquals("private", m1.getModifierList().getText());
    PsiMethod m2 = psiClass.findMethodsByName("m2", false)[0];
    assertEquals("private synchronized", m2.getModifierList().getText());
  }
}