Move configuring module with the library to utils method

idea/tests/org/jetbrains/jet/completion/JetBasicCompletionTest.java

@@ -16,8 +16,10 @@
 
 package org.jetbrains.jet.completion;
 
+import com.intellij.openapi.roots.OrderRootType;
+import com.intellij.openapi.roots.ui.configuration.libraryEditor.NewLibraryEditor;
+import com.intellij.openapi.vfs.VfsUtil;
 import org.jetbrains.annotations.NotNull;
-import org.jetbrains.jet.plugin.JetJdkAndLibraryProjectDescriptor;
 import org.jetbrains.jet.plugin.PluginTestCaseBase;
 import org.jetbrains.jet.testing.ConfigLibraryUtil;
 
@@ -297,15 +299,16 @@ public class JetBasicCompletionTest extends JetCompletionTestBase {
     }
 
     public void doTestWithJar() {
-        File libraryFile = new File(getTestDataPath() + "/" + getTestName(false) + ".jar");
+        NewLibraryEditor editor = new NewLibraryEditor(null, null);
-        JetJdkAndLibraryProjectDescriptor projectDescriptor = new JetJdkAndLibraryProjectDescriptor(libraryFile);
+        editor.setName("doTestWithJarLib");
+        editor.addRoot(VfsUtil.getUrlForLibraryRoot(new File(getTestDataPath() + "/" + getTestName(false) + ".jar")), OrderRootType.CLASSES);
 
         try {
-            ConfigLibraryUtil.configureLibrary(getModule(), getFullJavaJDK(), projectDescriptor);
+            ConfigLibraryUtil.configureLibrary(getModule(), getFullJavaJDK(), editor);
             doTest();
         }
         finally {
-            ConfigLibraryUtil.unConfigureLibrary(getModule(), getFullJavaJDK(), projectDescriptor);
+            ConfigLibraryUtil.unConfigureLibrary(getModule(), getFullJavaJDK(), editor.getName());
         }
     }
 

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

@@ -1,3 +1,4 @@
+/*
 /*
  * Copyright 2010-2013 JetBrains s.r.o.
  *
@@ -20,27 +21,24 @@ import com.intellij.openapi.module.Module;
 import com.intellij.openapi.module.ModuleType;
 import com.intellij.openapi.module.StdModuleTypes;
 import com.intellij.openapi.projectRoots.Sdk;
-import com.intellij.openapi.roots.*;
+import com.intellij.openapi.roots.ContentEntry;
-import com.intellij.openapi.roots.libraries.Library;
+import com.intellij.openapi.roots.ModifiableRootModel;
+import com.intellij.openapi.roots.OrderRootType;
+import com.intellij.openapi.roots.ui.configuration.libraryEditor.NewLibraryEditor;
 import com.intellij.openapi.vfs.VfsUtil;
 import com.intellij.testFramework.LightProjectDescriptor;
 import org.jetbrains.annotations.NotNull;
 import org.jetbrains.annotations.Nullable;
+import org.jetbrains.jet.testing.ConfigLibraryUtil;
 
 import java.io.File;
 
 public class JetJdkAndLibraryProjectDescriptor implements LightProjectDescriptor {
+    private static final String LIBRARY_NAME = "myLibrary";
 
-    private final String libraryName = "myLibrary";
     private final File libraryFile;
     private final OrderRootType libraryRootType;
 
-    public JetJdkAndLibraryProjectDescriptor(File libraryFile, OrderRootType libraryRootType) {
-        assert libraryFile.exists() : "Library file doesn't exist: " + libraryFile.getAbsolutePath();
-        this.libraryFile = libraryFile;
-        this.libraryRootType = libraryRootType;
-    }
-
     public JetJdkAndLibraryProjectDescriptor(File libraryFile) {
         assert libraryFile.exists() : "Library file doesn't exist: " + libraryFile.getAbsolutePath();
         this.libraryFile = libraryFile;
@@ -59,35 +57,10 @@ public class JetJdkAndLibraryProjectDescriptor implements LightProjectDescriptor
 
     @Override
     public void configureModule(@NotNull Module module, @NotNull ModifiableRootModel model, @Nullable ContentEntry contentEntry) {
-        Library library = model.getModuleLibraryTable().createLibrary(libraryName);
+        NewLibraryEditor editor = new NewLibraryEditor();
-        Library.ModifiableModel modifiableModel = library.getModifiableModel();
+        editor.setName(LIBRARY_NAME);
-        modifiableModel.addRoot(VfsUtil.getUrlForLibraryRoot(libraryFile), libraryRootType);
+        editor.addRoot(VfsUtil.getUrlForLibraryRoot(libraryFile), libraryRootType);
-        modifiableModel.commit();
-    }
 
-    public void unConfigureModule(@NotNull ModifiableRootModel model) {
+        ConfigLibraryUtil.addLibrary(editor, model);
-        for (OrderEntry orderEntry : model.getOrderEntries()) {
-            if (orderEntry instanceof LibraryOrderEntry) {
-                LibraryOrderEntry libraryOrderEntry = (LibraryOrderEntry) orderEntry;
-
-                Library library = libraryOrderEntry.getLibrary();
-                if (library != null) {
-                    String libraryName = library.getName();
-                    if (libraryName != null && libraryName.equals(this.libraryName)) {
-
-                        // Dispose attached roots
-                        Library.ModifiableModel modifiableModel = library.getModifiableModel();
-                        for (String rootUrl : library.getRootProvider().getUrls(OrderRootType.CLASSES)) {
-                            modifiableModel.removeRoot(rootUrl, OrderRootType.CLASSES);
-                        }
-                        modifiableModel.commit();
-
-                        model.getModuleLibraryTable().removeLibrary(library);
-
-                        break;
-                    }
-                }
-            }
-        }
     }
 }

idea/tests/org/jetbrains/jet/plugin/quickfix/AbstractQuickFixTest.java

@@ -34,11 +34,11 @@ public abstract class AbstractQuickFixTest extends LightQuickFixTestCase {
     protected void doTest(@NotNull String beforeFileName) throws Exception {
         boolean isWithRuntime = beforeFileName.endsWith("Runtime.kt");
 
-        if (isWithRuntime) {
-            ConfigLibraryUtil.configureKotlinRuntime(getModule(), getFullJavaJDK());
-        }
-
         try {
+            if (isWithRuntime) {
+                ConfigLibraryUtil.configureKotlinRuntime(getModule(), getFullJavaJDK());
+            }
+
             doSingleTest(getTestName(false) + ".kt");
             checkAvailableActionsAreExpected();
             checkForUnexpectedErrors();

idea/tests/org/jetbrains/jet/testing/ConfigLibraryUtil.java

@@ -19,63 +19,128 @@ package org.jetbrains.jet.testing;
 import com.intellij.openapi.application.ApplicationManager;
 import com.intellij.openapi.module.Module;
 import com.intellij.openapi.projectRoots.Sdk;
-import com.intellij.openapi.roots.ModifiableRootModel;
+import com.intellij.openapi.roots.*;
-import com.intellij.openapi.roots.ModuleRootManager;
+import com.intellij.openapi.roots.impl.libraries.LibraryEx;
-import com.intellij.testFramework.LightProjectDescriptor;
+import com.intellij.openapi.roots.libraries.Library;
+import com.intellij.openapi.roots.ui.configuration.libraryEditor.NewLibraryEditor;
+import com.intellij.openapi.util.Computable;
+import com.intellij.openapi.vfs.VfsUtil;
 import org.jetbrains.annotations.NotNull;
-import org.jetbrains.jet.plugin.JetJdkAndLibraryProjectDescriptor;
+import org.jetbrains.jet.codegen.forTestCompile.ForTestCompileRuntime;
-import org.jetbrains.jet.plugin.JetWithJdkAndRuntimeLightProjectDescriptor;
 
 /**
  * Helper for configuring kotlin runtime in tested project.
  */
 public class ConfigLibraryUtil {
+    private static final String DEFAULT_JAVA_RUNTIME_LIB_NAME = "JAVA_RUNTIME_LIB_NAME";
+
     private ConfigLibraryUtil() {
     }
 
+    private static NewLibraryEditor getKotlinRuntimeLibEditor(String libName) {
+        NewLibraryEditor editor = new NewLibraryEditor();
+        editor.setName(libName);
+        editor.addRoot(VfsUtil.getUrlForLibraryRoot(ForTestCompileRuntime.runtimeJarForTests()), OrderRootType.CLASSES);
+
+        return editor;
+    }
+
     public static void configureKotlinRuntime(Module module, Sdk sdk) {
-        configureLibrary(module, sdk, JetWithJdkAndRuntimeLightProjectDescriptor.INSTANCE);
+        configureLibrary(module, sdk, getKotlinRuntimeLibEditor(DEFAULT_JAVA_RUNTIME_LIB_NAME));
     }
 
     public static void unConfigureKotlinRuntime(Module module, Sdk sdk) {
-        unConfigureLibrary(module, sdk, JetWithJdkAndRuntimeLightProjectDescriptor.INSTANCE);
+        unConfigureLibrary(module, sdk, DEFAULT_JAVA_RUNTIME_LIB_NAME);
     }
 
-    public static void configureLibrary(
+    public static void configureLibrary(Module module, Sdk sdk, NewLibraryEditor libraryEditor) {
+        configureSdk(module, sdk);
+        addLibrary(libraryEditor, module);
+    }
+
+    public static void unConfigureLibrary(final Module module, final Sdk sdk, String libraryName) {
+        configureSdk(module, sdk);
+        removeLibrary(module, libraryName);
+    }
+
+    public static void configureSdk(
             @NotNull final Module module,
-            @NotNull final Sdk sdk,
+            @NotNull final Sdk sdk) {
-            @NotNull final LightProjectDescriptor projectDescriptor
-    ) {
         ApplicationManager.getApplication().runWriteAction(new Runnable() {
             @Override
             public void run() {
-
+                final ModuleRootManager rootManager = ModuleRootManager.getInstance(module);
-                ModuleRootManager rootManager = ModuleRootManager.getInstance(module);
+                final ModifiableRootModel rootModel = rootManager.getModifiableModel();
-                ModifiableRootModel rootModel = rootManager.getModifiableModel();
 
                 rootModel.setSdk(sdk);
-                projectDescriptor.configureModule(module, rootModel, null);
                 rootModel.commit();
             }
         });
     }
 
-    public static void unConfigureLibrary(
+    public static Library addLibrary(final NewLibraryEditor editor, final Module module) {
-            @NotNull final Module module,
+        return ApplicationManager.getApplication().runWriteAction(new Computable<Library>() {
-            @NotNull final Sdk sdk,
+            @Override
-            @NotNull final LightProjectDescriptor projectDescriptor
+            public Library compute() {
-    ) {
+                final ModuleRootManager rootManager = ModuleRootManager.getInstance(module);
+                ModifiableRootModel model = rootManager.getModifiableModel();
+
+                Library library = addLibrary(editor, model);
+
+                model.commit();
+
+                return library;
+            }
+        });
+    }
+
+    public static Library addLibrary(NewLibraryEditor editor, ModifiableRootModel model) {
+        Library library = model.getModuleLibraryTable().createLibrary(editor.getName());
+
+        final Library.ModifiableModel libModel = library.getModifiableModel();
+        editor.applyTo((LibraryEx.ModifiableModelEx) libModel);
+
+        libModel.commit();
+
+        return library;
+    }
+
+
+    public static void removeLibrary(@NotNull final Module module, @NotNull final String libraryName) {
         ApplicationManager.getApplication().runWriteAction(new Runnable() {
             @Override
             public void run() {
-                ModuleRootManager rootManager = ModuleRootManager.getInstance(module);
+                final ModuleRootManager rootManager = ModuleRootManager.getInstance(module);
-                ModifiableRootModel rootModel = rootManager.getModifiableModel();
+                final ModifiableRootModel model = rootManager.getModifiableModel();
 
-                rootModel.setSdk(sdk);
+                for (OrderEntry orderEntry : model.getOrderEntries()) {
-                if (projectDescriptor instanceof JetJdkAndLibraryProjectDescriptor) {
+                    if (orderEntry instanceof LibraryOrderEntry) {
-                    ((JetJdkAndLibraryProjectDescriptor) projectDescriptor).unConfigureModule(rootModel);
+                        LibraryOrderEntry libraryOrderEntry = (LibraryOrderEntry) orderEntry;
+
+                        Library library = libraryOrderEntry.getLibrary();
+                        if (library != null) {
+                            String name = library.getName();
+                            if (name != null && name.equals(libraryName)) {
+
+                                // Dispose attached roots
+                                Library.ModifiableModel modifiableModel = library.getModifiableModel();
+                                for (String rootUrl : library.getRootProvider().getUrls(OrderRootType.CLASSES)) {
+                                    modifiableModel.removeRoot(rootUrl, OrderRootType.CLASSES);
+                                }
+                                for (String rootUrl : library.getRootProvider().getUrls(OrderRootType.SOURCES)) {
+                                    modifiableModel.removeRoot(rootUrl, OrderRootType.SOURCES);
+                                }
+                                modifiableModel.commit();
+
+                                model.getModuleLibraryTable().removeLibrary(library);
+
+                                break;
+                            }
+                        }
+                    }
                 }
-                rootModel.commit();
+
+                model.commit();
             }
         });
     }