Using LightProjectDescriptor in navigate to library tests.

1.5x faster execution and reusable code.

idea/tests/org/jetbrains/jet/plugin/JdkAndMockLibraryProjectDescriptor.java

@@ -0,0 +1,137 @@
+package org.jetbrains.jet.plugin;
+
+import com.intellij.openapi.application.ApplicationManager;
+import com.intellij.openapi.module.Module;
+import com.intellij.openapi.roots.ContentEntry;
+import com.intellij.openapi.roots.ModifiableRootModel;
+import com.intellij.openapi.roots.OrderRootType;
+import com.intellij.openapi.roots.libraries.Library;
+import com.intellij.openapi.util.ThrowableComputable;
+import com.intellij.openapi.util.io.FileUtil;
+import com.intellij.openapi.vfs.LocalFileSystem;
+import com.intellij.openapi.vfs.VfsUtilCore;
+import com.intellij.openapi.vfs.VirtualFile;
+import com.intellij.openapi.vfs.VirtualFileVisitor;
+import com.intellij.openapi.vfs.newvfs.NewVirtualFile;
+import org.jetbrains.annotations.NotNull;
+import org.jetbrains.jet.JetTestUtils;
+import org.jetbrains.jet.cli.common.ExitCode;
+import org.jetbrains.jet.cli.jvm.K2JVMCompiler;
+import org.jetbrains.jet.utils.ExceptionUtils;
+import org.jetbrains.jet.utils.PathUtil;
+
+import java.io.ByteArrayOutputStream;
+import java.io.File;
+import java.io.IOException;
+import java.io.PrintStream;
+import java.lang.reflect.Method;
+import java.net.URL;
+import java.net.URLClassLoader;
+
+import static junit.framework.Assert.assertEquals;
+import static junit.framework.Assert.assertNotNull;
+
+public class JdkAndMockLibraryProjectDescriptor extends JetLightProjectDescriptor {
+    private final String sourcesPath;
+    private final boolean withSources;
+
+    public JdkAndMockLibraryProjectDescriptor(String sourcesPath, boolean withSources) {
+        this.sourcesPath = sourcesPath;
+        this.withSources = withSources;
+    }
+
+    @Override
+    public void configureModule(Module module, ModifiableRootModel model, ContentEntry contentEntry) {
+        try {
+            File compiledDir = compileTestLibrary(sourcesPath);
+
+            final VirtualFile baseDir = module.getProject().getBaseDir();
+            assertNotNull(baseDir);
+
+            VirtualFile libraryDir = ApplicationManager.getApplication().runWriteAction(new ThrowableComputable<VirtualFile, IOException>() {
+                @Override
+                public VirtualFile compute() throws IOException {
+                    VirtualFile libraryDir = baseDir.createChildDirectory(this, "lib");
+                    baseDir.createChildDirectory(this, "src");
+                    return libraryDir;
+                }
+            });
+
+            VirtualFile testDataDir = LocalFileSystem.getInstance().findFileByPath(sourcesPath).getParent();
+            assertNotNull(testDataDir);
+            VfsUtilCore.visitChildrenRecursively(testDataDir, new VirtualFileVisitor() {
+                @Override
+                public boolean visitFile(@NotNull VirtualFile file) {
+                    file.getChildren();
+                    file.refresh(false, true);
+                    return true;
+                }
+            });
+            VirtualFile librarySourceDir = LocalFileSystem.getInstance().findFileByPath(sourcesPath);
+            assertNotNull(librarySourceDir);
+
+            FileUtil.copyDir(compiledDir, new File(libraryDir.getPath()));
+
+            ((NewVirtualFile)baseDir).markDirtyRecursively();
+            baseDir.refresh(false, true);
+
+            Library.ModifiableModel libraryModel = model.getModuleLibraryTable().getModifiableModel().createLibrary("myKotlinLib").getModifiableModel();
+            libraryModel.addRoot(libraryDir, OrderRootType.CLASSES);
+            if (withSources) {
+                libraryModel.addRoot(librarySourceDir, OrderRootType.SOURCES);
+            }
+            libraryModel.commit();
+        }
+        catch (IOException e) {
+            throw new AssertionError(e);
+        }
+    }
+
+    private static File compileTestLibrary(String sourcesPath) {
+        try {
+            File compiledDir = JetTestUtils.tmpDir("dummylib");
+
+            ByteArrayOutputStream outStream = new ByteArrayOutputStream();
+
+            File kotlinCompilerJar = new File(PathUtil.getKotlinPathsForDistDirectory().getLibPath(), "kotlin-compiler.jar");
+            URLClassLoader classLoader = new URLClassLoader(new URL[] {kotlinCompilerJar.toURI().toURL()}, Object.class.getClassLoader());
+
+            Class<?> compilerClass = classLoader.loadClass(K2JVMCompiler.class.getName());
+            Object compilerObject = compilerClass.newInstance();
+            Method execMethod = compilerClass.getMethod("exec", PrintStream.class, String[].class);
+
+            //noinspection IOResourceOpenedButNotSafelyClosed
+            Enum<?> invocationResult = (Enum<?>) execMethod
+                    .invoke(compilerObject, new PrintStream(outStream),
+                            new String[] {"-src", sourcesPath, "-output", compiledDir.getAbsolutePath()});
+
+            assertEquals(new String(outStream.toByteArray()), ExitCode.OK.name(), invocationResult.name());
+
+            return compiledDir;
+        }
+        catch (Throwable e) {
+            throw ExceptionUtils.rethrow(e);
+        }
+    }
+
+
+    @Override
+    public boolean equals(Object o) {
+        if (this == o) return true;
+        if (o == null || getClass() != o.getClass()) return false;
+
+        JdkAndMockLibraryProjectDescriptor that = (JdkAndMockLibraryProjectDescriptor) o;
+
+        if (withSources != that.withSources) return false;
+        if (sourcesPath != null ? !sourcesPath.equals(that.sourcesPath) : that.sourcesPath != null) return false;
+
+        return true;
+    }
+
+    @Override
+    public int hashCode() {
+        int result = sourcesPath != null ? sourcesPath.hashCode() : 0;
+        result = 31 * result + (withSources ? 1 : 0);
+        return result;
+    }
+}

idea/tests/org/jetbrains/jet/plugin/JetLightProjectDescriptor.java

@@ -25,7 +25,7 @@ import com.intellij.openapi.roots.ModifiableRootModel;
 import com.intellij.testFramework.LightProjectDescriptor;
 
 public class JetLightProjectDescriptor implements LightProjectDescriptor {
-    private JetLightProjectDescriptor() {
+    protected JetLightProjectDescriptor() {
     }
     
     public static final JetLightProjectDescriptor INSTANCE = new JetLightProjectDescriptor();

idea/tests/org/jetbrains/jet/plugin/libraries/AbstractNavigateToLibraryTest.java

@@ -16,105 +16,10 @@
 
 package org.jetbrains.jet.plugin.libraries;
 
-import com.intellij.openapi.application.ApplicationManager;
+import com.intellij.testFramework.fixtures.LightCodeInsightFixtureTestCase;
-import com.intellij.openapi.roots.ModifiableRootModel;
-import com.intellij.openapi.roots.ModuleRootManager;
-import com.intellij.openapi.roots.OrderRootType;
-import com.intellij.openapi.roots.libraries.Library;
-import com.intellij.openapi.util.ThrowableComputable;
-import com.intellij.openapi.util.io.FileUtil;
-import com.intellij.openapi.vfs.LocalFileSystem;
-import com.intellij.openapi.vfs.VfsUtilCore;
-import com.intellij.openapi.vfs.VirtualFile;
-import com.intellij.openapi.vfs.VirtualFileVisitor;
-import com.intellij.openapi.vfs.newvfs.NewVirtualFile;
-import com.intellij.testFramework.PlatformTestCase;
-import org.jetbrains.annotations.NotNull;
-import org.jetbrains.jet.JetTestUtils;
-import org.jetbrains.jet.cli.common.ExitCode;
-import org.jetbrains.jet.cli.jvm.K2JVMCompiler;
 import org.jetbrains.jet.plugin.PluginTestCaseBase;
 
-import java.io.ByteArrayOutputStream;
+public abstract class AbstractNavigateToLibraryTest extends LightCodeInsightFixtureTestCase {
-import java.io.File;
-import java.io.IOException;
-import java.io.PrintStream;
-
-public abstract class AbstractNavigateToLibraryTest extends PlatformTestCase {
     protected static final String PACKAGE = "testData.libraries";
     protected static final String TEST_DATA_PATH = PluginTestCaseBase.getTestDataPathBase() + "/libraries";
-    protected static final String SOURCES_PATH = TEST_DATA_PATH + "/library";
-    protected static final String SRC_DIR_NAME = "src";
-    private static File tempDirWithCompiled;
-
-    protected abstract boolean isWithSources();
-
-    @NotNull
-    private static File getTempDirWithCompiled() throws Exception {
-        if (tempDirWithCompiled == null) {
-            tempDirWithCompiled = JetTestUtils.tmpDir("dummylib");
-
-            ByteArrayOutputStream outStream = new ByteArrayOutputStream();
-
-            ExitCode compilerExec = new K2JVMCompiler().exec(
-                    new PrintStream(outStream), "-src", SOURCES_PATH, "-output", tempDirWithCompiled.getAbsolutePath());
-            assertEquals(new String(outStream.toByteArray()), ExitCode.OK, compilerExec);
-        }
-
-        return tempDirWithCompiled;
-    }
-
-    @Override
-    protected void setUp() throws Exception {
-        super.setUp();
-        final VirtualFile baseDir = getProject().getBaseDir();
-        assertNotNull(baseDir);
-
-        final VirtualFile libraryDir = ApplicationManager.getApplication().runWriteAction(new ThrowableComputable<VirtualFile, IOException>() {
-            @Override
-            public VirtualFile compute() throws IOException {
-                VirtualFile libraryDir = baseDir.createChildDirectory(this, "lib");
-                baseDir.createChildDirectory(this, SRC_DIR_NAME);
-                return libraryDir;
-            }
-        });
-
-        VirtualFile testDataDir = LocalFileSystem.getInstance().findFileByPath(TEST_DATA_PATH);
-        assertNotNull(testDataDir);
-        VfsUtilCore.visitChildrenRecursively(testDataDir, new VirtualFileVisitor() {
-            @Override
-            public boolean visitFile(@NotNull VirtualFile file) {
-                file.getChildren();
-                file.refresh(false, true);
-                return true;
-            }
-        });
-        final VirtualFile librarySourceDir = LocalFileSystem.getInstance().findFileByPath(SOURCES_PATH);
-        assertNotNull(librarySourceDir);
-
-        FileUtil.copyDir(getTempDirWithCompiled(), new File(libraryDir.getPath()));
-
-        ((NewVirtualFile)baseDir).markDirtyRecursively();
-        baseDir.refresh(false, true);
-
-        ApplicationManager.getApplication().runWriteAction(new Runnable() {
-            @Override
-            public void run() {
-                ModifiableRootModel moduleModel = ModuleRootManager.getInstance(myModule).getModifiableModel();
-
-                Library.ModifiableModel libraryModel = moduleModel.getModuleLibraryTable().getModifiableModel().createLibrary("myKotlinLib").getModifiableModel();
-                libraryModel.addRoot(libraryDir, OrderRootType.CLASSES);
-                if (isWithSources()) {
-                    libraryModel.addRoot(librarySourceDir, OrderRootType.SOURCES);
-                }
-                libraryModel.commit();
-
-                VirtualFile srcDir = baseDir.findChild(SRC_DIR_NAME);
-                assertNotNull(srcDir);
-                moduleModel.addContentEntry(srcDir).addSourceFolder(srcDir, false);
-
-                moduleModel.commit();
-            }
-        });
-    }
 }

idea/tests/org/jetbrains/jet/plugin/libraries/NavigateToDecompiledLibraryTest.java

@@ -27,10 +27,12 @@ import com.intellij.openapi.util.TextRange;
 import com.intellij.openapi.util.text.StringUtil;
 import com.intellij.openapi.vfs.VirtualFile;
 import com.intellij.psi.util.PsiTreeUtil;
+import com.intellij.testFramework.LightProjectDescriptor;
 import org.jetbrains.annotations.NotNull;
 import org.jetbrains.annotations.Nullable;
 import org.jetbrains.jet.lang.psi.JetDeclaration;
 import org.jetbrains.jet.lang.psi.JetFile;
+import org.jetbrains.jet.plugin.JdkAndMockLibraryProjectDescriptor;
 
 import java.util.Map;
 
@@ -123,7 +125,7 @@ public class NavigateToDecompiledLibraryTest extends AbstractNavigateToLibraryTe
 
     @Nullable
     private LibraryOrderEntry findOurTestLibrary() {
-        for (OrderEntry orderEntry : ModuleRootManager.getInstance(getModule()).getOrderEntries()) {
+        for (OrderEntry orderEntry : ModuleRootManager.getInstance(myModule).getOrderEntries()) {
             if (orderEntry instanceof LibraryOrderEntry) {
                 return (LibraryOrderEntry) orderEntry;
             }
@@ -142,11 +144,6 @@ public class NavigateToDecompiledLibraryTest extends AbstractNavigateToLibraryTe
         return classFile;
     }
 
-    @Override
-    protected boolean isWithSources() {
-        return false;
-    }
-
     @NotNull
     private static Map<String, JetDeclaration> getRenderedDescriptorToKotlinPsiMap(
             @NotNull JetFile file, @NotNull Map<String, TextRange> renderedDescriptorsToRanges
@@ -163,4 +160,10 @@ public class NavigateToDecompiledLibraryTest extends AbstractNavigateToLibraryTe
         }
         return renderedDescriptorsToJetDeclarations;
     }
+
+    @NotNull
+    @Override
+    protected LightProjectDescriptor getProjectDescriptor() {
+        return new JdkAndMockLibraryProjectDescriptor(TEST_DATA_PATH + "/library", false);
+    }
 }

idea/tests/org/jetbrains/jet/plugin/libraries/NavigateToLibrarySourceTest.java

@@ -16,9 +16,11 @@
 
 package org.jetbrains.jet.plugin.libraries;
 
+import com.intellij.openapi.application.ApplicationManager;
 import com.intellij.openapi.editor.Document;
 import com.intellij.openapi.editor.EditorFactory;
 import com.intellij.openapi.fileEditor.FileDocumentManager;
+import com.intellij.openapi.roots.ModuleRootManager;
 import com.intellij.openapi.roots.ProjectFileIndex;
 import com.intellij.openapi.util.Pair;
 import com.intellij.openapi.vfs.LocalFileSystem;
@@ -29,9 +31,11 @@ import com.intellij.psi.PsiDocumentManager;
 import com.intellij.psi.PsiElement;
 import com.intellij.psi.PsiFile;
 import com.intellij.psi.PsiReference;
+import com.intellij.testFramework.LightProjectDescriptor;
 import com.intellij.util.containers.MultiMap;
 import org.jetbrains.annotations.NotNull;
 import org.jetbrains.jet.JetTestUtils;
+import org.jetbrains.jet.plugin.JdkAndMockLibraryProjectDescriptor;
 import org.jetbrains.jet.plugin.references.JetPsiReference;
 
 import java.io.IOException;
@@ -92,7 +96,12 @@ public class NavigateToLibrarySourceTest extends AbstractNavigateToLibraryTest {
     }
 
     private void doTest() {
-        userFile = copyFileToSrcDir(TEST_DATA_PATH + "/usercode/" + getTestName(false) + ".kt");
+        ApplicationManager.getApplication().runWriteAction(new Runnable() {
+            @Override
+            public void run() {
+                userFile = copyFileToSrcDir(TEST_DATA_PATH + "/usercode/" + getTestName(false) + ".kt");
+            }
+        });
 
         checkAnnotatedLibraryCode(false);
         checkAnnotatedLibraryCode(true);
@@ -197,18 +206,13 @@ public class NavigateToLibrarySourceTest extends AbstractNavigateToLibraryTest {
         return JetTestUtils.getLastCommentedLines(document);
     }
 
-    @Override
-    protected boolean isWithSources() {
-        return true;
-    }
-
 
     @NotNull
     private VirtualFile copyFileToSrcDir(@NotNull String path) {
         VirtualFile originalFile = LocalFileSystem.getInstance().findFileByPath(path);
         assertNotNull(originalFile);
 
-        VirtualFile srcDir = getProject().getBaseDir().findChild(SRC_DIR_NAME);
+        VirtualFile srcDir = ModuleRootManager.getInstance(myModule).getSourceRoots()[0];
         assertNotNull(srcDir);
         try {
             VfsUtilCore.copyFile(null, originalFile, srcDir);
@@ -224,4 +228,10 @@ public class NavigateToLibrarySourceTest extends AbstractNavigateToLibraryTest {
         assertNotNull(result);
         return result;
     }
+
+    @NotNull
+    @Override
+    protected LightProjectDescriptor getProjectDescriptor() {
+        return new JdkAndMockLibraryProjectDescriptor(TEST_DATA_PATH + "/library", true);
+    }
 }