IDEA-204753 Gradle: multi-module project creation is broken (IDEA-205334)

2026-09-27 10:03:11 +07:00 · 2019-01-21 10:47:45 +03:00
parent 1c881066bb
commit 5bbce3fb0a
10 changed files with 298 additions and 151 deletions
@@ -181,17 +181,25 @@ public class ProjectDataManagerImpl implements ProjectDataManager {
      trace.logPerformance("Data import total", System.currentTimeMillis() - allStartTime);
    }
    catch (Throwable t) {
-      runFinalTasks(synchronous, onFailureImportTasks);
-      dispose(modelsProvider, project, synchronous);
-      ExceptionUtil.rethrowAllAsUnchecked(t);
+      try {
+        runFinalTasks(project, synchronous, onFailureImportTasks);
+        dispose(modelsProvider, project, synchronous);
+      }
+      finally {
+        //noinspection ConstantConditions
+        ExceptionUtil.rethrowAllAsUnchecked(t);
+      }
    }
-    runFinalTasks(synchronous, onSuccessImportTasks);
+    runFinalTasks(project, synchronous, onSuccessImportTasks);
  }

-  private static void runFinalTasks(boolean synchronous, List<Runnable> tasks) {
-    Runnable runnable = () -> {
-      for (Runnable task : ContainerUtil.reverse(tasks)) {
-        task.run();
+  private static void runFinalTasks(@NotNull Project project, boolean synchronous, List<Runnable> tasks) {
+    Runnable runnable = new DisposeAwareProjectChange(project) {
+      @Override
+      public void execute() {
+        for (Runnable task : ContainerUtil.reverse(tasks)) {
+          task.run();
+        }
      }
    };
    if (synchronous) {
@@ -1,5 +1,6 @@
 package com.intellij.openapi.externalSystem.service.ui;

+import com.intellij.openapi.application.ApplicationManager;
 import com.intellij.openapi.externalSystem.ExternalSystemManager;
 import com.intellij.openapi.externalSystem.model.ProjectSystemId;
 import com.intellij.openapi.externalSystem.settings.AbstractExternalSystemSettings;
@@ -11,6 +12,7 @@ import com.intellij.openapi.project.Project;
 import com.intellij.openapi.startup.StartupManager;
 import com.intellij.openapi.wm.ToolWindow;
 import com.intellij.openapi.wm.ToolWindowManager;
+import com.intellij.openapi.wm.impl.ToolWindowHeadlessManagerImpl;
 import com.intellij.openapi.wm.impl.ToolWindowImpl;
 import com.intellij.util.ui.UIUtil;
 import org.jetbrains.annotations.NotNull;
@@ -71,7 +73,7 @@ public class ExternalToolWindowManager {
  }

  @Nullable
-  private static ToolWindow getToolWindow(@NotNull Project project, @NotNull ProjectSystemId externalSystemId) {
+  public static ToolWindow getToolWindow(@NotNull Project project, @NotNull ProjectSystemId externalSystemId) {
    final ToolWindowManager toolWindowManager = ToolWindowManager.getInstance(project);
    if (toolWindowManager == null) {
      return null;
@@ -80,6 +82,9 @@ public class ExternalToolWindowManager {
    if (result instanceof ToolWindowImpl) {
      ((ToolWindowImpl)result).ensureContentInitialized();
    }
+    if (result == null && ApplicationManager.getApplication().isUnitTestMode()) {
+      result = new ToolWindowHeadlessManagerImpl.MockToolWindow(project);
+    }
    return result;
  }
 }
@@ -21,13 +21,12 @@ import com.intellij.openapi.externalSystem.model.ProjectSystemId;
 import com.intellij.openapi.externalSystem.model.project.ProjectData;
 import com.intellij.openapi.externalSystem.service.project.ProjectDataManager;
 import com.intellij.openapi.externalSystem.service.project.manage.ExternalProjectsManagerImpl;
-import com.intellij.openapi.externalSystem.view.ExternalProjectsStructure;
-import com.intellij.openapi.externalSystem.view.ExternalProjectsView;
-import com.intellij.openapi.externalSystem.view.ExternalProjectsViewAdapter;
-import com.intellij.openapi.externalSystem.view.ExternalSystemNode;
+import com.intellij.openapi.externalSystem.view.*;
 import com.intellij.openapi.project.Project;
 import com.intellij.openapi.ui.DialogWrapper;
 import com.intellij.openapi.util.Disposer;
+import com.intellij.openapi.wm.ToolWindow;
+import com.intellij.openapi.wm.ex.ToolWindowEx;
 import com.intellij.ui.ScrollPaneFactory;
 import com.intellij.ui.treeStructure.SimpleNode;
 import com.intellij.ui.treeStructure.SimpleNodeVisitor;
@@ -79,7 +78,14 @@ public class SelectExternalSystemNodeDialog extends DialogWrapper {
    myTree = new SimpleTree();
    myTree.getSelectionModel().setSelectionMode(TreeSelectionModel.SINGLE_TREE_SELECTION);

-    final ExternalProjectsView projectsView = ExternalProjectsManagerImpl.getInstance(project).getExternalProjectsView(systemId);
+    ExternalProjectsView projectsView = ExternalProjectsManagerImpl.getInstance(project).getExternalProjectsView(systemId);
+    if (projectsView == null) {
+      ToolWindow toolWindow = ExternalToolWindowManager.getToolWindow(project, systemId);
+      if (toolWindow instanceof ToolWindowEx) {
+        projectsView = new ExternalProjectsViewImpl(project, (ToolWindowEx)toolWindow, systemId);
+        Disposer.register(getDisposable(), (ExternalProjectsViewImpl)projectsView);
+      }
+    }
    if(projectsView != null) {
      final ExternalProjectsStructure treeStructure = new ExternalProjectsStructure(project, myTree) {
        @Override
@@ -15,6 +15,7 @@ import com.intellij.openapi.module.ModuleManager;
 import com.intellij.openapi.module.ModuleType;
 import com.intellij.openapi.module.StdModuleTypes;
 import com.intellij.openapi.project.Project;
+import com.intellij.openapi.project.ProjectUtil;
 import com.intellij.openapi.projectRoots.Sdk;
 import com.intellij.openapi.projectRoots.impl.JavaAwareProjectJdkTableImpl;
 import com.intellij.openapi.roots.ModuleRootModificationUtil;
@@ -155,37 +156,14 @@ public abstract class ExternalSystemTestCase extends UsefulTestCase {
  @After
  @Override
  public void tearDown() throws Exception {
-    try {
-      EdtTestUtil.runInEdtAndWait(() -> {
-        tearDownFixtures();
-      });
-      myProject = null;
-      if (!FileUtil.delete(myTestDir) && myTestDir.exists()) {
-        System.err.println("Cannot delete " + myTestDir);
-        //printDirectoryContent(myDir);
-        myTestDir.deleteOnExit();
-      }
-    }
-    catch (Throwable e) {
-      addSuppressedException(e);
-    }
-    finally {
-      super.tearDown();
-      resetClassFields(getClass());
-    }
-  }
-
-  private static void printDirectoryContent(File dir) {
-    File[] files = dir.listFiles();
-    if (files == null) return;
-
-    for (File file : files) {
-      System.out.println(file.getAbsolutePath());
-
-      if (file.isDirectory()) {
-        printDirectoryContent(file);
-      }
-    }
+    new RunAll(
+      () -> EdtTestUtil.runInEdtAndWait(() -> tearDownFixtures()),
+      () -> myProject = null,
+      () -> PathKt.delete(myTestDir.toPath()),
+      () -> PathKt.delete(ProjectUtil.getExternalConfigurationDir(myProject)),
+      () -> super.tearDown(),
+      () -> resetClassFields(getClass())
+    ).run();
  }

  protected void tearDownFixtures() {
@@ -16,7 +16,10 @@ import com.intellij.openapi.externalSystem.ExternalStateComponent;
 import com.intellij.openapi.externalSystem.ExternalSystemModulePropertyManager;
 import com.intellij.openapi.externalSystem.importing.ImportSpec;
 import com.intellij.openapi.externalSystem.importing.ImportSpecBuilder;
+import com.intellij.openapi.externalSystem.model.DataNode;
 import com.intellij.openapi.externalSystem.model.ExternalSystemDataKeys;
+import com.intellij.openapi.externalSystem.model.ProjectKeys;
+import com.intellij.openapi.externalSystem.model.internal.InternalExternalProjectInfo;
 import com.intellij.openapi.externalSystem.model.project.ProjectData;
 import com.intellij.openapi.externalSystem.model.project.ProjectId;
 import com.intellij.openapi.externalSystem.service.execution.ProgressExecutionMode;
@@ -234,6 +237,12 @@ public class GradleModuleBuilder extends AbstractExternalModuleBuilder<GradlePro
      project.putUserData(ExternalSystemDataKeys.NEWLY_CREATED_PROJECT, Boolean.TRUE);
      //noinspection unchecked
      settings.linkProject(getExternalProjectSettings());
+      // update external projects data to be able to add child modules before the initial import finish
+      ProjectData projectData = new ProjectData(GradleConstants.SYSTEM_ID, project.getName(), myWizardContext.getProjectFileDirectory(),
+                                                getExternalProjectSettings().getExternalProjectPath());
+      DataNode<ProjectData> projectDataNode = new DataNode<>(ProjectKeys.PROJECT, projectData, null);
+      ExternalProjectsManagerImpl.getInstance(project).updateExternalProjectData(
+        new InternalExternalProjectInfo(GradleConstants.SYSTEM_ID, getExternalProjectSettings().getExternalProjectPath(), projectDataNode));
    }
    else {
      FileDocumentManager.getInstance().saveAllDocuments();
@@ -17,6 +17,7 @@ import com.intellij.openapi.util.text.StringUtil;
 import com.intellij.openapi.wm.IdeFocusManager;
 import org.jetbrains.annotations.NotNull;
 import org.jetbrains.annotations.Nullable;
+import org.jetbrains.annotations.TestOnly;
 import org.jetbrains.plugins.gradle.util.GradleConstants;

 import javax.swing.*;
@@ -243,5 +244,10 @@ public class GradleModuleWizardStep extends ModuleWizardStep {
  public void disposeUIResources() {
    Disposer.dispose(myParentProjectForm);
  }
+
+  @TestOnly
+  public void setArtifactId(@NotNull String artifactId) {
+    myArtifactIdField.setText(artifactId);
+  }
 }

@@ -19,6 +19,7 @@ import com.intellij.openapi.externalSystem.util.ExternalSystemApiUtil;
 import com.intellij.openapi.fileTypes.FileTypes;
 import com.intellij.openapi.project.Project;
 import com.intellij.openapi.project.ProjectManager;
+import com.intellij.openapi.util.io.FileUtil;
 import com.intellij.openapi.util.text.StringUtil;
 import com.intellij.ui.EditorTextField;
 import com.intellij.util.ArrayUtil;
@@ -130,8 +131,18 @@ public class GradleParentProjectForm implements Disposable {
  private ProjectData findPotentialParentProject(@Nullable Project project) {
    if (project == null) return null;

-    ExternalProjectSettings linkedProjectSettings =
-      ExternalSystemApiUtil.getSettings(project, GradleConstants.SYSTEM_ID).getLinkedProjectSettings(myContext.getProjectFileDirectory());
+    String contextProjectFileDirectory = myContext.getProjectFileDirectory();
+    ExternalProjectSettings linkedProjectSettings = null;
+    for (Object settings : ExternalSystemApiUtil.getSettings(project, GradleConstants.SYSTEM_ID).getLinkedProjectsSettings()) {
+      if (settings instanceof ExternalProjectSettings) {
+        String projectPath = ((ExternalProjectSettings)settings).getExternalProjectPath();
+        if (FileUtil.isAncestor(projectPath, contextProjectFileDirectory, false)) {
+          linkedProjectSettings = (ExternalProjectSettings)settings;
+          break;
+        }
+      }
+    }
+
    if(linkedProjectSettings == null) return null;

    final ExternalProjectInfo projectInfo =
@@ -1,89 +0,0 @@
-/*
- * Copyright 2000-2013 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 org.jetbrains.plugins.gradle;
-
-import com.intellij.ide.projectWizard.NewProjectWizardTestCase;
-import com.intellij.ide.projectWizard.ProjectTypeStep;
-import com.intellij.ide.util.projectWizard.ModuleWizardStep;
-import com.intellij.ide.util.projectWizard.ProjectBuilder;
-import com.intellij.openapi.module.Module;
-import com.intellij.openapi.module.ModuleManager;
-import com.intellij.openapi.project.Project;
-import com.intellij.openapi.roots.ModuleRootManager;
-import com.intellij.openapi.roots.ProjectRootManager;
-import com.intellij.openapi.util.text.StringUtil;
-import com.intellij.openapi.vfs.VfsUtilCore;
-import com.intellij.openapi.vfs.VirtualFile;
-import org.jetbrains.plugins.gradle.service.project.wizard.GradleModuleBuilder;
-
-import java.util.List;
-
-/**
- * @author Dmitry Avdeev
- */
-public class GradleProjectWizardTest extends NewProjectWizardTestCase {
-
-  public void testGradleProject() throws Exception {
-    final String projectName = "testProject";
-    Project project = createProject(step -> {
-      if (step instanceof ProjectTypeStep) {
-        assertTrue(((ProjectTypeStep)step).setSelectedTemplate("Gradle", null));
-        List<ModuleWizardStep> steps = myWizard.getSequence().getSelectedSteps();
-        assertEquals(5, steps.size());
-        final ProjectBuilder projectBuilder = myWizard.getProjectBuilder();
-        assertInstanceOf(projectBuilder, GradleModuleBuilder.class);
-        ((GradleModuleBuilder)projectBuilder).setName(projectName);
-      }
-    });
-
-    assertEquals(projectName, project.getName());
-    Module[] modules = ModuleManager.getInstance(project).getModules();
-    assertEquals(1, modules.length);
-    final Module module = modules[0];
-    assertTrue(ModuleRootManager.getInstance(module).isSdkInherited());
-    assertEquals(projectName, module.getName());
-
-    VirtualFile root = ProjectRootManager.getInstance(project).getContentRoots()[0];
-    VirtualFile settingsScript = VfsUtilCore.findRelativeFile("settings.gradle", root);
-    assertNotNull(settingsScript);
-    assertEquals(String.format("rootProject.name = '%s'\n\n", projectName),
-                 StringUtil.convertLineSeparators(VfsUtilCore.loadText(settingsScript)));
-
-    VirtualFile buildScript = VfsUtilCore.findRelativeFile("build.gradle", root);
-    assertNotNull(buildScript);
-    assertEquals("plugins {\n" +
-                 "    id 'java'\n" +
-                 "}\n\n" +
-                 "version '1.0-SNAPSHOT'\n" +
-                 "\n" +
-                 "sourceCompatibility = 1.8\n" +
-                 "\n" +
-                 "repositories {\n" +
-                 "    mavenCentral()\n" +
-                 "}\n" +
-                 "\n" +
-                 "dependencies {\n" +
-                 "    testCompile group: 'junit', name: 'junit', version: '4.12'\n" +
-                 "}\n",
-                 StringUtil.convertLineSeparators(VfsUtilCore.loadText(buildScript)));
-  }
-
-  @Override
-  protected void setUp() throws Exception {
-    super.setUp();
-    configureJdk();
-  }
-}
@@ -0,0 +1,214 @@
+// Copyright 2000-2019 JetBrains s.r.o. Use of this source code is governed by the Apache 2.0 license that can be found in the LICENSE file.
+package org.jetbrains.plugins.gradle.importing;
+
+import com.intellij.ide.projectWizard.NewProjectWizardTestCase;
+import com.intellij.ide.projectWizard.ProjectTypeStep;
+import com.intellij.ide.util.projectWizard.ModuleWizardStep;
+import com.intellij.ide.util.projectWizard.ProjectBuilder;
+import com.intellij.openapi.application.ApplicationManager;
+import com.intellij.openapi.application.PathManager;
+import com.intellij.openapi.application.WriteAction;
+import com.intellij.openapi.externalSystem.service.project.ProjectDataManager;
+import com.intellij.openapi.externalSystem.service.project.manage.ExternalProjectsDataStorage;
+import com.intellij.openapi.externalSystem.service.ui.SelectExternalProjectDialog;
+import com.intellij.openapi.externalSystem.settings.ExternalProjectSettings;
+import com.intellij.openapi.externalSystem.util.ExternalSystemApiUtil;
+import com.intellij.openapi.externalSystem.view.ProjectNode;
+import com.intellij.openapi.module.Module;
+import com.intellij.openapi.module.ModuleManager;
+import com.intellij.openapi.project.Project;
+import com.intellij.openapi.project.ProjectManager;
+import com.intellij.openapi.project.ProjectManagerListener;
+import com.intellij.openapi.project.ProjectUtil;
+import com.intellij.openapi.projectRoots.ProjectJdkTable;
+import com.intellij.openapi.projectRoots.Sdk;
+import com.intellij.openapi.projectRoots.SimpleJavaSdkType;
+import com.intellij.openapi.projectRoots.impl.SdkConfigurationUtil;
+import com.intellij.openapi.roots.ModuleRootManager;
+import com.intellij.openapi.roots.ProjectRootManager;
+import com.intellij.openapi.util.io.FileUtil;
+import com.intellij.openapi.util.text.StringUtil;
+import com.intellij.openapi.vfs.LocalFileSystem;
+import com.intellij.openapi.vfs.VfsUtilCore;
+import com.intellij.openapi.vfs.VirtualFile;
+import com.intellij.openapi.vfs.newvfs.impl.VfsRootAccess;
+import com.intellij.testFramework.IdeaTestUtil;
+import com.intellij.testFramework.RunAll;
+import com.intellij.ui.treeStructure.SimpleTree;
+import com.intellij.util.ArrayUtil;
+import com.intellij.util.Consumer;
+import com.intellij.util.containers.ContainerUtil;
+import com.intellij.util.ui.UIUtil;
+import org.jetbrains.annotations.NotNull;
+import org.jetbrains.annotations.Nullable;
+import org.jetbrains.plugins.gradle.service.project.wizard.GradleModuleBuilder;
+import org.jetbrains.plugins.gradle.service.project.wizard.GradleModuleWizardStep;
+import org.jetbrains.plugins.gradle.util.GradleConstants;
+
+import javax.swing.*;
+import java.io.File;
+import java.io.IOException;
+import java.util.ArrayList;
+import java.util.Collection;
+import java.util.List;
+
+import static com.intellij.openapi.externalSystem.test.ExternalSystemTestCase.collectRootsInside;
+
+/**
+ * @author Dmitry Avdeev
+ */
+public class GradleProjectWizardTest extends NewProjectWizardTestCase {
+
+  protected static final String GRADLE_JDK_NAME = "Gradle JDK";
+  private String myJdkHome;
+
+  public void testGradleProject() throws Exception {
+    final String projectName = "testProject";
+    ApplicationManager.getApplication().getMessageBus().connect().subscribe(ProjectManager.TOPIC, new ProjectManagerListener() {
+      @Override
+      public void projectOpened(@NotNull Project project) {
+        assertNotEmpty(ProjectDataManager.getInstance().getExternalProjectsData(project, GradleConstants.SYSTEM_ID));
+        try {
+          // project save is not called in unit mode, see com.intellij.ide.impl.NewProjectUtil.doCreate
+          ExternalProjectsDataStorage.getInstance(project).saveAndWait();
+        }
+        catch (Exception e) {
+          fail(e.getMessage());
+        }
+      }
+    });
+
+    Project project = createProject(step -> {
+      if (step instanceof ProjectTypeStep) {
+        assertTrue(((ProjectTypeStep)step).setSelectedTemplate("Gradle", null));
+        List<ModuleWizardStep> steps = myWizard.getSequence().getSelectedSteps();
+        assertEquals(5, steps.size());
+        final ProjectBuilder projectBuilder = myWizard.getProjectBuilder();
+        assertInstanceOf(projectBuilder, GradleModuleBuilder.class);
+        ((GradleModuleBuilder)projectBuilder).setName(projectName);
+      }
+    });
+
+    assertEquals(projectName, project.getName());
+    Module[] modules = ModuleManager.getInstance(project).getModules();
+    assertEquals(1, modules.length);
+    final Module module = modules[0];
+    assertTrue(ModuleRootManager.getInstance(module).isSdkInherited());
+    assertEquals(projectName, module.getName());
+
+    VirtualFile root = ProjectRootManager.getInstance(project).getContentRoots()[0];
+    VirtualFile settingsScript = VfsUtilCore.findRelativeFile("settings.gradle", root);
+    assertNotNull(settingsScript);
+    assertEquals(String.format("rootProject.name = '%s'\n\n", projectName),
+                 StringUtil.convertLineSeparators(VfsUtilCore.loadText(settingsScript)));
+
+    VirtualFile buildScript = VfsUtilCore.findRelativeFile("build.gradle", root);
+    assertNotNull(buildScript);
+    assertEquals("plugins {\n" +
+                 "    id 'java'\n" +
+                 "}\n\n" +
+                 "version '1.0-SNAPSHOT'\n" +
+                 "\n" +
+                 "sourceCompatibility = 1.8\n" +
+                 "\n" +
+                 "repositories {\n" +
+                 "    mavenCentral()\n" +
+                 "}\n" +
+                 "\n" +
+                 "dependencies {\n" +
+                 "    testCompile group: 'junit', name: 'junit', version: '4.12'\n" +
+                 "}\n",
+                 StringUtil.convertLineSeparators(VfsUtilCore.loadText(buildScript)));
+
+    Module childModule = createModuleFromTemplate("Gradle", null, project, step -> {
+      if (step instanceof ProjectTypeStep) {
+        List<ModuleWizardStep> steps = myWizard.getSequence().getSelectedSteps();
+        assertEquals(5, steps.size());
+      }
+      else if (step instanceof GradleModuleWizardStep) {
+        SelectExternalProjectDialog projectDialog = new SelectExternalProjectDialog(GradleConstants.SYSTEM_ID, project, null);
+        JComponent component = projectDialog.getPreferredFocusedComponent();
+        ProjectNode projectNode = (ProjectNode)((SimpleTree)component).getNodeFor(0);
+        assertEquals(projectName, projectNode.getName());
+        ((GradleModuleWizardStep)step).setArtifactId("childModule");
+      }
+    });
+
+    modules = ModuleManager.getInstance(project).getModules();
+    assertEquals(2, modules.length);
+
+    assertEquals("childModule", childModule.getName());
+    assertEquals(String.format("rootProject.name = '%s'\n" +
+                               "include '%s'\n\n", projectName, childModule.getName()),
+                 StringUtil.convertLineSeparators(VfsUtilCore.loadText(settingsScript)));
+  }
+
+  @Override
+  protected Project createProject(Consumer adjuster) throws IOException {
+    @SuppressWarnings("unchecked") Project project = super.createProject(adjuster);
+    myFilesToDelete.add(ProjectUtil.getExternalConfigurationDir(project).toFile());
+    return project;
+  }
+
+  @Override
+  protected void createWizard(@Nullable Project project) throws IOException {
+    Collection linkedProjectsSettings = project == null
+                                        ? ContainerUtil.emptyList()
+                                        : ExternalSystemApiUtil.getSettings(project, GradleConstants.SYSTEM_ID).getLinkedProjectsSettings();
+    assertTrue(linkedProjectsSettings.size() <= 1);
+    File directory;
+    Object settings = ContainerUtil.getFirstItem(linkedProjectsSettings);
+    if (settings instanceof ExternalProjectSettings) {
+      directory =
+        FileUtil.createTempDirectory(new File(((ExternalProjectSettings)settings).getExternalProjectPath()), getName(), "new", false);
+    }
+    else {
+      directory = FileUtil.createTempDirectory(getName(), "new", false);
+    }
+    myFilesToDelete.add(directory);
+    myWizard = createWizard(project, directory);
+    UIUtil.dispatchAllInvocationEvents(); // to make default selection applied
+  }
+
+  protected void collectAllowedRoots(final List<String> roots) {
+    roots.add(myJdkHome);
+    roots.addAll(collectRootsInside(myJdkHome));
+    roots.add(PathManager.getConfigPath());
+  }
+
+  @Override
+  protected void setUp() throws Exception {
+    super.setUp();
+    myJdkHome = IdeaTestUtil.requireRealJdkHome();
+    List<String> allowedRoots = new ArrayList<>();
+    collectAllowedRoots(allowedRoots);
+    if (!allowedRoots.isEmpty()) {
+      VfsRootAccess.allowRootAccess(getTestRootDisposable(), ArrayUtil.toStringArray(allowedRoots));
+    }
+    WriteAction.runAndWait(() -> {
+      Sdk oldJdk = ProjectJdkTable.getInstance().findJdk(GRADLE_JDK_NAME);
+      if (oldJdk != null) {
+        ProjectJdkTable.getInstance().removeJdk(oldJdk);
+      }
+      VirtualFile jdkHomeDir = LocalFileSystem.getInstance().refreshAndFindFileByIoFile(new File(myJdkHome));
+      Sdk jdk = SdkConfigurationUtil.setupSdk(new Sdk[0], jdkHomeDir, SimpleJavaSdkType.getInstance(), true, null, GRADLE_JDK_NAME);
+      assertNotNull("Cannot create JDK for " + myJdkHome, jdk);
+      ProjectJdkTable.getInstance().addJdk(jdk);
+    });
+  }
+
+  @Override
+  public void tearDown() {
+    new RunAll(
+      () -> {
+        if (myJdkHome != null) {
+          Sdk jdk = ProjectJdkTable.getInstance().findJdk(GRADLE_JDK_NAME);
+          if (jdk != null) {
+            WriteAction.runAndWait(() -> ProjectJdkTable.getInstance().removeJdk(jdk));
+          }
+        }
+      },
+      () -> super.tearDown()
+    ).run();
+  }
+}
@@ -18,6 +18,7 @@ import com.intellij.openapi.vfs.LocalFileSystem;
 import com.intellij.openapi.vfs.VirtualFile;
 import com.intellij.openapi.vfs.newvfs.impl.VfsRootAccess;
 import com.intellij.testFramework.IdeaTestUtil;
+import com.intellij.testFramework.RunAll;
 import com.intellij.util.ArrayUtil;
 import com.intellij.util.PathUtil;
 import com.intellij.util.containers.ContainerUtil;
@@ -105,21 +106,19 @@ public abstract class GradleImportingTestCase extends ExternalSystemImportingTes
      //super.setUp() wasn't called
      return;
    }
-    Sdk jdk = ProjectJdkTable.getInstance().findJdk(GRADLE_JDK_NAME);
-    if (jdk != null) {
-      WriteAction.runAndWait(() -> ProjectJdkTable.getInstance().removeJdk(jdk));
-    }
-
-    try {
-      Messages.setTestDialog(TestDialog.DEFAULT);
-      deleteBuildSystemDirectory();
-    }
-    catch (Throwable e) {
-      addSuppressedException(e);
-    }
-    finally {
-      super.tearDown();
-    }
+    new RunAll(
+      () -> {
+        Sdk jdk = ProjectJdkTable.getInstance().findJdk(GRADLE_JDK_NAME);
+        if (jdk != null) {
+          WriteAction.runAndWait(() -> ProjectJdkTable.getInstance().removeJdk(jdk));
+        }
+      },
+      () -> {
+        Messages.setTestDialog(TestDialog.DEFAULT);
+        deleteBuildSystemDirectory();
+      },
+      () -> super.tearDown()
+    ).run();
  }

  @Override