Gradle: convert app level delegation settings to IDE level (IDEA-176794, IDEA-173354)

2026-09-27 10:03:11 +07:00 · 2018-12-03 08:31:05 +03:00
parent ccb66097ed
commit d82a6e8b5e
16 changed files with 360 additions and 193 deletions
@@ -47,9 +47,9 @@ import org.jetbrains.annotations.NotNull;
 import org.jetbrains.annotations.Nullable;
 import org.jetbrains.plugins.gradle.service.project.GradleBuildSrcProjectsResolver;
 import org.jetbrains.plugins.gradle.service.project.GradleProjectResolverUtil;
+import org.jetbrains.plugins.gradle.service.settings.GradleSettingsService;
 import org.jetbrains.plugins.gradle.service.task.GradleTaskManager;
 import org.jetbrains.plugins.gradle.settings.GradleSettings;
-import org.jetbrains.plugins.gradle.settings.GradleSystemRunningSettings;
 import org.jetbrains.plugins.gradle.util.GradleConstants;

 import java.io.File;
@@ -179,7 +179,7 @@ public class GradleProjectTaskRunner extends ProjectTaskRunner {
  public boolean canRun(@NotNull ProjectTask projectTask) {
    if (projectTask instanceof ModuleBuildTask) {
      Module module = ((ModuleBuildTask)projectTask).getModule();
-      if (!GradleSystemRunningSettings.getInstance().isDelegatedBuildEnabled(module)) return false;
+      if (!GradleSettingsService.isDelegatedBuildEnabled(module)) return false;
      return isExternalSystemAwareModule(GradleConstants.SYSTEM_ID, module);
    }
    if (projectTask instanceof ProjectModelBuildTask) {
@@ -196,13 +196,10 @@ public class GradleProjectTaskRunner extends ProjectTaskRunner {
      if (runProfile instanceof ModuleBasedConfiguration) {
        RunConfigurationModule module = ((ModuleBasedConfiguration)runProfile).getConfigurationModule();
        if (!isExternalSystemAwareModule(GradleConstants.SYSTEM_ID, module.getModule()) ||
-            !GradleSystemRunningSettings.getInstance().isDelegatedBuildEnabled(module.getModule())) {
+            !GradleSettingsService.isDelegatedBuildEnabled(module.getModule())) {
          return false;
        }
      }
-      else if (!GradleSystemRunningSettings.getInstance().isDelegatedBuildEnabledByDefault()) {
-        return false;
-      }
      for (GradleExecutionEnvironmentProvider environmentProvider : GradleExecutionEnvironmentProvider.EP_NAME.getExtensions()) {
        if (environmentProvider.isApplicable(((ExecuteRunConfigurationTask)projectTask))) {
          return true;
@@ -30,13 +30,14 @@ import org.jetbrains.plugins.gradle.execution.GradleRunnerUtil;
 import org.jetbrains.plugins.gradle.service.execution.GradleRunConfiguration;
 import org.jetbrains.plugins.gradle.service.project.GradleProjectResolverUtil;
 import org.jetbrains.plugins.gradle.service.resolve.GradleCommonClassNames;
-import org.jetbrains.plugins.gradle.settings.GradleSystemRunningSettings;
+import org.jetbrains.plugins.gradle.service.settings.GradleSettingsService;
+import org.jetbrains.plugins.gradle.settings.TestRunner;
 import org.jetbrains.plugins.gradle.util.GradleConstants;

 import java.util.List;

 import static com.intellij.openapi.util.text.StringUtil.endsWithChar;
-import static org.jetbrains.plugins.gradle.settings.GradleSystemRunningSettings.PreferredTestRunner.*;
+import static org.jetbrains.plugins.gradle.settings.TestRunner.*;

 /**
 * @author Vladislav.Soroka
@@ -51,13 +52,13 @@ public abstract class GradleTestRunConfigurationProducer extends RunConfiguratio

  @Override
  public boolean isPreferredConfiguration(ConfigurationFromContext self, ConfigurationFromContext other) {
-    GradleSystemRunningSettings.PreferredTestRunner testRunner = getTestRunner(self.getSourceElement());
-    return testRunner == CHOOSE_PER_TEST || testRunner == GRADLE_TEST_RUNNER;
+    TestRunner testRunner = getTestRunner(self.getSourceElement());
+    return testRunner == CHOOSE_PER_TEST || testRunner == GRADLE;
  }

  @Override
  public boolean shouldReplace(@NotNull ConfigurationFromContext self, @NotNull ConfigurationFromContext other) {
-    return getTestRunner(self.getSourceElement()) == GRADLE_TEST_RUNNER;
+    return getTestRunner(self.getSourceElement()) == GRADLE;
  }

  @Override
@@ -67,8 +68,8 @@ public abstract class GradleTestRunConfigurationProducer extends RunConfiguratio
    if (!GradleConstants.SYSTEM_ID.equals(configuration.getSettings().getExternalSystemId())) return false;

    if (sourceElement.isNull()) return false;
-    GradleSystemRunningSettings.PreferredTestRunner testRunner = getTestRunner(sourceElement.get());
-    if (testRunner == PLATFORM_TEST_RUNNER) return false;
+    TestRunner testRunner = getTestRunner(sourceElement.get());
+    if (testRunner == PLATFORM) return false;
    if (configuration instanceof GradleRunConfiguration) {
      final GradleRunConfiguration gradleRunConfiguration = (GradleRunConfiguration)configuration;
      gradleRunConfiguration.setScriptDebugEnabled(false);
@@ -82,13 +83,12 @@ public abstract class GradleTestRunConfigurationProducer extends RunConfiguratio

  @Override
  public boolean isConfigurationFromContext(ExternalSystemRunConfiguration configuration, ConfigurationContext context) {
-    if (GradleSystemRunningSettings.getInstance().getDefaultTestRunner() == PLATFORM_TEST_RUNNER) return false;
    if (configuration == null) return false;
    if (!GradleConstants.SYSTEM_ID.equals(configuration.getSettings().getExternalSystemId())) return false;

    String projectPath = configuration.getSettings().getExternalProjectPath();
-    GradleSystemRunningSettings.PreferredTestRunner testRunner = getTestRunner(context.getProject(), projectPath);
-    if (testRunner == PLATFORM_TEST_RUNNER) return false;
+    TestRunner testRunner = getTestRunner(context.getProject(), projectPath);
+    if (testRunner == PLATFORM) return false;
    return doIsConfigurationFromContext(configuration, context);
  }

@@ -150,19 +150,19 @@ public abstract class GradleTestRunConfigurationProducer extends RunConfiguratio
    return ContainerUtil.map(tasks, task -> taskPrefix + task);
  }

-  private static GradleSystemRunningSettings.PreferredTestRunner getTestRunner(@NotNull Project project, @NotNull String projectPath) {
-    return GradleSystemRunningSettings.getInstance().getTestRunner(project, projectPath);
+  private static TestRunner getTestRunner(@NotNull Project project, @NotNull String projectPath) {
+    return GradleSettingsService.getInstance(project).getTestRunner(projectPath);
  }

-  private static GradleSystemRunningSettings.PreferredTestRunner getTestRunner(@NotNull PsiElement sourceElement) {
+  private static TestRunner getTestRunner(@NotNull PsiElement sourceElement) {
    PsiFile containingFile = sourceElement.getContainingFile();
    if (containingFile != null) {
      VirtualFile file = containingFile.getVirtualFile();
      Module module = file == null ? null : ProjectFileIndex.SERVICE.getInstance(sourceElement.getProject()).getModuleForFile(file);
      if (module != null) {
-        return GradleSystemRunningSettings.getInstance().getTestRunner(module);
+        return GradleSettingsService.getTestRunner(module);
      }
    }
-    return GradleSystemRunningSettings.getInstance().getDefaultTestRunner();
+    return PLATFORM;
  }
 }
@@ -73,9 +73,9 @@
                         instance="org.jetbrains.plugins.gradle.service.settings.GradleConfigurable"
                         key="gradle.name" bundle="i18n.GradleBundle">
    </projectConfigurable>
-    <applicationConfigurable parentId="reference.settingsdialog.project.gradle"
-                             instance="org.jetbrains.plugins.gradle.settings.GradleRunnerConfigurable"
-                             id="reference.settings.project.gradle.running" key="gradle.runner" bundle="i18n.GradleBundle"/>
+    <projectConfigurable parentId="reference.settingsdialog.project.gradle"
+                         instance="org.jetbrains.plugins.gradle.settings.GradleRunnerConfigurable"
+                         id="reference.settings.project.gradle.running" key="gradle.runner" bundle="i18n.GradleBundle"/>
    <editorTabTitleProvider implementation="org.jetbrains.plugins.gradle.util.GradleEditorTabTitleProvider"/>
    <configurationType implementation="org.jetbrains.plugins.gradle.service.execution.GradleExternalTaskConfigurationType"/>

@@ -93,8 +93,10 @@

    <applicationService serviceImplementation="org.jetbrains.plugins.gradle.service.GradleInstallationManager"/>

+    <projectService serviceImplementation="org.jetbrains.plugins.gradle.service.settings.GradleSettingsService"/>
    <applicationService serviceImplementation="org.jetbrains.plugins.gradle.settings.GradleSystemSettings"/>
    <applicationService serviceImplementation="org.jetbrains.plugins.gradle.settings.GradleSystemRunningSettings"/>
+    <projectService serviceImplementation="org.jetbrains.plugins.gradle.settings.DefaultGradleProjectSettings"/>
    <projectService serviceImplementation="org.jetbrains.plugins.gradle.settings.GradleSettings"/>
    <projectService serviceImplementation="org.jetbrains.plugins.gradle.settings.GradleLocalSettings"/>
    <projectService serviceImplementation="org.jetbrains.plugins.gradle.service.project.GradleNotification"/>
@@ -11,7 +11,7 @@ gradle.settings.text.use.gradle.aware.make=Delegate IDE build/run actions to gra
 gradle.settings.text.delegate.panel.title=Delegate settings
 gradle.settings.text.delegate.buildRun=Build and run using
 gradle.settings.text.delegate.testRunner=Run tests using
-gradle.settings.text.use.application.default=Use application default
+gradle.settings.text.use.default=Use default

 gradle.settings.text.home.path=Gradle home:
 gradle.settings.text.jvm.path=Gradle JVM:
@@ -49,8 +49,8 @@ gradle.codeInsight.action.add_maven_dependency.description=Add selected maven ar
 gradle.runner=Runner
 gradle.runner.toggle.tree.text.action.name=Toggle tasks executions/text mode
 gradle.preferred_test_runner.CHOOSE_PER_TEST=Choose per test
-gradle.preferred_test_runner.PLATFORM_TEST_RUNNER=Platform Test Runner
-gradle.preferred_test_runner.GRADLE_TEST_RUNNER=Gradle Test Runner
+gradle.preferred_test_runner.PLATFORM=Platform Test Runner
+gradle.preferred_test_runner.GRADLE=Gradle Test Runner
 gradle.test.runner.ui.tests.tree.presentation.labels.waiting.tests=Waiting for tests...
 gradle.test.runner.ui.tests.tree.presentation.labels.no.tests.were.found=Test events were not received
 gradle.test.runner.ui.tests.actions.open.gradle.report.text=Open Gradle test report
@@ -21,6 +21,7 @@ import com.intellij.openapi.externalSystem.ExternalSystemModulePropertyManager;
 import com.intellij.openapi.externalSystem.model.project.ExternalSystemSourceType;
 import com.intellij.openapi.externalSystem.util.ExternalSystemApiUtil;
 import com.intellij.openapi.module.Module;
+import com.intellij.openapi.project.Project;
 import com.intellij.openapi.roots.ModuleRootModel;
 import com.intellij.openapi.roots.OrderEnumerationHandler;
 import com.intellij.openapi.roots.OrderRootType;
@@ -32,10 +33,8 @@ import org.jetbrains.plugins.gradle.model.ExternalProject;
 import org.jetbrains.plugins.gradle.model.ExternalSourceDirectorySet;
 import org.jetbrains.plugins.gradle.model.ExternalSourceSet;
 import org.jetbrains.plugins.gradle.service.project.data.ExternalProjectDataCache;
-import org.jetbrains.plugins.gradle.settings.GradleLocalSettings;
-import org.jetbrains.plugins.gradle.settings.GradleProjectSettings;
-import org.jetbrains.plugins.gradle.settings.GradleSettings;
-import org.jetbrains.plugins.gradle.settings.GradleSystemRunningSettings;
+import org.jetbrains.plugins.gradle.service.settings.GradleSettingsService;
+import org.jetbrains.plugins.gradle.settings.*;
 import org.jetbrains.plugins.gradle.util.GradleConstants;

 import java.io.File;
@@ -111,7 +110,8 @@ public class GradleOrderEnumeratorHandler extends OrderEnumerationHandler {
      return false;
    }

-    final ExternalProjectDataCache externalProjectDataCache = ExternalProjectDataCache.getInstance(rootModel.getModule().getProject());
+    Project project = rootModel.getModule().getProject();
+    final ExternalProjectDataCache externalProjectDataCache = ExternalProjectDataCache.getInstance(project);
    assert externalProjectDataCache != null;
    final ExternalProject externalRootProject =
      externalProjectDataCache.getRootExternalProject(GradleConstants.SYSTEM_ID, new File(gradleProjectPath));
@@ -124,7 +124,7 @@ public class GradleOrderEnumeratorHandler extends OrderEnumerationHandler {
      externalProjectDataCache.findExternalProject(externalRootProject, rootModel.getModule());
    if (externalSourceSets.isEmpty()) return false;

-    boolean isDelegatedBuildEnabled = GradleSystemRunningSettings.getInstance().isDelegatedBuildEnabled(rootModel.getModule());
+    boolean isDelegatedBuildEnabled = GradleSettingsService.getInstance(project).isDelegatedBuildEnabled(rootModel.getModule());
    for (ExternalSourceSet sourceSet : externalSourceSets.values()) {
      if (includeTests) {
        if (isDelegatedBuildEnabled) {
@@ -16,8 +16,8 @@ import com.intellij.openapi.project.Project
 import com.intellij.util.ObjectUtils.consumeIfCast
 import com.intellij.util.ThreeState
 import org.jetbrains.plugins.gradle.execution.GradleBeforeRunTaskProvider
+import org.jetbrains.plugins.gradle.settings.TestRunner.*
 import org.jetbrains.plugins.gradle.settings.GradleSettings
-import org.jetbrains.plugins.gradle.settings.GradleSystemRunningSettings
 import org.jetbrains.plugins.gradle.util.GradleConstants

 class GradleBeforeRunTaskImporter: BeforeRunTaskImporter {
@@ -104,9 +104,9 @@ class ActionDelegateConfigImporter: ConfigurationHandler {

  companion object {
    private val TEST_RUNNER_MAP = mapOf(
-      "PLATFORM" to GradleSystemRunningSettings.PreferredTestRunner.PLATFORM_TEST_RUNNER,
-      "GRADLE" to GradleSystemRunningSettings.PreferredTestRunner.GRADLE_TEST_RUNNER,
-      "CHOOSE_PER_TEST" to GradleSystemRunningSettings.PreferredTestRunner.CHOOSE_PER_TEST
+      "PLATFORM" to PLATFORM,
+      "GRADLE" to GRADLE,
+      "CHOOSE_PER_TEST" to CHOOSE_PER_TEST
    )
  }
 }
@@ -0,0 +1,67 @@
+// Copyright 2000-2018 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.service.settings;
+
+import com.intellij.openapi.components.ServiceManager;
+import com.intellij.openapi.externalSystem.util.ExternalSystemApiUtil;
+import com.intellij.openapi.module.Module;
+import com.intellij.openapi.project.Project;
+import com.intellij.util.ThreeState;
+import org.jetbrains.annotations.NotNull;
+import org.jetbrains.plugins.gradle.settings.DefaultGradleProjectSettings;
+import org.jetbrains.plugins.gradle.settings.GradleProjectSettings;
+import org.jetbrains.plugins.gradle.settings.GradleSettings;
+import org.jetbrains.plugins.gradle.settings.TestRunner;
+
+/**
+ * {@link GradleSettingsService} provides effective settings for linked gradle projects.
+ *
+ * @see GradleProjectSettings
+ * @see DefaultGradleProjectSettings
+ *
+ * @author Vladislav.Soroka
+ */
+public class GradleSettingsService {
+  @NotNull
+  private final Project myProject;
+
+  public GradleSettingsService(@NotNull Project project) {
+    myProject = project;
+  }
+
+  public boolean isDelegatedBuildEnabled(@NotNull String gradleProjectPath) {
+    GradleProjectSettings projectSettings = GradleSettings.getInstance(myProject).getLinkedProjectSettings(gradleProjectPath);
+    if (projectSettings == null) return false;
+    if (projectSettings.getDelegatedBuild() == ThreeState.UNSURE) {
+      return DefaultGradleProjectSettings.getInstance(myProject).isDelegatedBuild();
+    }
+    return projectSettings.getDelegatedBuild().toBoolean();
+  }
+
+  @NotNull
+  public TestRunner getTestRunner(@NotNull String gradleProjectPath) {
+    GradleProjectSettings projectSettings = GradleSettings.getInstance(myProject).getLinkedProjectSettings(gradleProjectPath);
+    return projectSettings == null || projectSettings.getTestRunner() == null
+           ? DefaultGradleProjectSettings.getInstance(myProject).getTestRunner()
+           : projectSettings.getTestRunner();
+  }
+
+  public static boolean isDelegatedBuildEnabled(@NotNull Module module) {
+    String projectPath = ExternalSystemApiUtil.getExternalRootProjectPath(module);
+    if (projectPath == null) return false;
+    return getInstance(module.getProject()).isDelegatedBuildEnabled(projectPath);
+  }
+
+  @NotNull
+  public static TestRunner getTestRunner(@NotNull Module module) {
+    String projectPath = ExternalSystemApiUtil.getExternalRootProjectPath(module);
+    if (projectPath == null) {
+      return DefaultGradleProjectSettings.getInstance(module.getProject()).getTestRunner();
+    }
+    return getInstance(module.getProject()).getTestRunner(projectPath);
+  }
+
+  @NotNull
+  public static GradleSettingsService getInstance(@NotNull Project project) {
+    return ServiceManager.getService(project, GradleSettingsService.class);
+  }
+}
@@ -2,6 +2,7 @@
 package org.jetbrains.plugins.gradle.service.settings;

 import com.intellij.ide.util.projectWizard.WizardContext;
+import com.intellij.openapi.Disposable;
 import com.intellij.openapi.actionSystem.CustomShortcutSet;
 import com.intellij.openapi.application.ApplicationBundle;
 import com.intellij.openapi.application.ApplicationManager;
@@ -21,6 +22,8 @@ import com.intellij.openapi.projectRoots.Sdk;
 import com.intellij.openapi.roots.ui.configuration.projectRoot.ProjectSdksModel;
 import com.intellij.openapi.roots.ui.util.CompositeAppearance;
 import com.intellij.openapi.ui.*;
+import com.intellij.openapi.util.Disposer;
+import com.intellij.openapi.util.Ref;
 import com.intellij.openapi.util.SystemInfo;
 import com.intellij.openapi.util.io.FileUtil;
 import com.intellij.openapi.util.registry.Registry;
@@ -41,9 +44,10 @@ import org.gradle.util.GradleVersion;
 import org.jetbrains.annotations.NotNull;
 import org.jetbrains.annotations.Nullable;
 import org.jetbrains.plugins.gradle.service.GradleInstallationManager;
+import org.jetbrains.plugins.gradle.settings.DefaultGradleProjectSettings;
 import org.jetbrains.plugins.gradle.settings.DistributionType;
 import org.jetbrains.plugins.gradle.settings.GradleProjectSettings;
-import org.jetbrains.plugins.gradle.settings.GradleSystemRunningSettings;
+import org.jetbrains.plugins.gradle.settings.TestRunner;
 import org.jetbrains.plugins.gradle.util.GradleBundle;
 import org.jetbrains.plugins.gradle.util.GradleConstants;
 import org.jetbrains.plugins.gradle.util.GradleUtil;
@@ -146,6 +150,16 @@ public class IdeaGradleProjectSettingsControlBuilder implements GradleProjectSet
  @Nullable
  private JPanel myGradleJdkPanel;

+  /**
+   * The target {@link Project} reference of the UI control.
+   * It can be the current project of the settings UI configurable (see {@org.jetbrains.plugins.gradle.service.settings.GradleConfigurable}),
+   * or the target project from the wizard context.
+   */
+  @NotNull
+  private final Ref<Project> myProjectRef = Ref.create();
+  @NotNull
+  private final Disposable myProjectRefDisposable = () -> myProjectRef.set(null);
+
  public IdeaGradleProjectSettingsControlBuilder(@NotNull GradleProjectSettings initialSettings) {
    myInstallationManager = ServiceManager.getService(GradleInstallationManager.class);
    myInitialSettings = initialSettings;
@@ -561,6 +575,8 @@ public class IdeaGradleProjectSettingsControlBuilder implements GradleProjectSet
                    GradleProjectSettings settings,
                    boolean isDefaultModuleCreation,
                    @Nullable WizardContext wizardContext) {
+    updateProjectRef(project, wizardContext);
+
    String gradleHome = settings.getGradleHome();
    if (myGradleHomePathField != null) {
      myGradleHomePathField.setText(gradleHome == null ? "" : gradleHome);
@@ -764,20 +780,20 @@ public class IdeaGradleProjectSettingsControlBuilder implements GradleProjectSet
      BuildRunItem[] states = StreamEx.of(ThreeState.values()).map(BuildRunItem::new).toArray(BuildRunItem[]::new);
      myDelegateBuildCombobox = new ComboBox<>(states);
      myDelegateBuildCombobox.setRenderer(new MyItemCellRenderer<>());
-      myDelegateBuildCombobox.setSelectedItem(BuildRunItem.from(myInitialSettings.getDelegatedBuild()));
+      myDelegateBuildCombobox.setSelectedItem(new BuildRunItem(myInitialSettings.getDelegatedBuild()));

      myDelegateBuildLabel = new JBLabel(GradleBundle.message("gradle.settings.text.delegate.buildRun"));
      myDelegatePanel.add(myDelegateBuildLabel, getLabelConstraints(labelLevel));
      myDelegatePanel.add(myDelegateBuildCombobox);
    }
    if (!dropTestRunnerCombobox) {
-      TestRunnerItem[] testRunners = StreamEx.of(GradleSystemRunningSettings.PreferredTestRunner.values())
-        .append((GradleSystemRunningSettings.PreferredTestRunner)null)
+      TestRunnerItem[] testRunners = StreamEx.of(TestRunner.values())
+        .append((TestRunner)null)
        .map(TestRunnerItem::new)
        .toArray(TestRunnerItem[]::new);
      myTestRunnerCombobox = new ComboBox<>(testRunners);
      myTestRunnerCombobox.setRenderer(new MyItemCellRenderer<>());
-      myTestRunnerCombobox.setSelectedItem(TestRunnerItem.from(myInitialSettings.getTestRunner()));
+      myTestRunnerCombobox.setSelectedItem(new TestRunnerItem(myInitialSettings.getTestRunner()));

      myTestRunnerLabel = new JBLabel(GradleBundle.message("gradle.settings.text.delegate.testRunner"));
      myDelegatePanel.add(myTestRunnerLabel, getLabelConstraints(labelLevel));
@@ -802,10 +818,10 @@ public class IdeaGradleProjectSettingsControlBuilder implements GradleProjectSet
      return;
    }
    if (myDelegateBuildCombobox != null) {
-      myDelegateBuildCombobox.setSelectedItem(BuildRunItem.from(myInitialSettings.getDelegatedBuild()));
+      myDelegateBuildCombobox.setSelectedItem(new BuildRunItem(myInitialSettings.getDelegatedBuild()));
    }
    if (myTestRunnerCombobox != null) {
-      myTestRunnerCombobox.setSelectedItem(TestRunnerItem.from(myInitialSettings.getTestRunner()));
+      myTestRunnerCombobox.setSelectedItem(new TestRunnerItem(myInitialSettings.getTestRunner()));
    }
  }

@@ -836,6 +852,17 @@ public class IdeaGradleProjectSettingsControlBuilder implements GradleProjectSet
    }
  }

+  private void updateProjectRef(@Nullable Project project, @Nullable WizardContext wizardContext) {
+    if (wizardContext != null && wizardContext.getProject() != null) {
+      project = wizardContext.getProject();
+    }
+    if (project != null && project != myProjectRef.get()
+        && Disposer.findRegisteredObject(project, myProjectRefDisposable) == null) {
+      Disposer.register(project, myProjectRefDisposable);
+    }
+    myProjectRef.set(project);
+  }
+
  private class DelayedBalloonInfo implements Runnable {
    private final MessageType myMessageType;
    private final String myText;
@@ -922,7 +949,7 @@ public class IdeaGradleProjectSettingsControlBuilder implements GradleProjectSet
    }
  }

-  private static class BuildRunItem extends MyItem<ThreeState> {
+  private class BuildRunItem extends MyItem<ThreeState> {

    private BuildRunItem(@Nullable ThreeState value) {
      super(value);
@@ -936,28 +963,27 @@ public class IdeaGradleProjectSettingsControlBuilder implements GradleProjectSet
    @Override
    protected String getComment() {
      if (value != ThreeState.UNSURE) return null;
-      return getText(ThreeState.fromBoolean(GradleSystemRunningSettings.getInstance().isDelegatedBuildEnabledByDefault()));
-    }
-
-    private static BuildRunItem from(ThreeState value) {
-      return new BuildRunItem(value);
+      ThreeState defaultDelegationOption =
+        myProjectRef.isNull() ? null :
+        ThreeState.fromBoolean(DefaultGradleProjectSettings.getInstance(myProjectRef.get()).isDelegatedBuild());
+      return getText(defaultDelegationOption);
    }

    @NotNull
-    private static String getText(@Nullable ThreeState state) {
+    private String getText(@Nullable ThreeState state) {
      if (state == ThreeState.NO) {
        return ApplicationNamesInfo.getInstance().getFullProductName();
      }
      if (state == ThreeState.YES) {
        return "Gradle";
      }
-      return GradleBundle.message("gradle.settings.text.use.application.default");
+      return GradleBundle.message("gradle.settings.text.use.default");
    }
  }

-  private static class TestRunnerItem extends MyItem<GradleSystemRunningSettings.PreferredTestRunner> {
+  private class TestRunnerItem extends MyItem<TestRunner> {

-    private TestRunnerItem(@Nullable GradleSystemRunningSettings.PreferredTestRunner value) {
+    private TestRunnerItem(@Nullable TestRunner value) {
      super(value);
    }

@@ -968,25 +994,24 @@ public class IdeaGradleProjectSettingsControlBuilder implements GradleProjectSet

    @Override
    protected String getComment() {
-      return value != null ? null : getText(GradleSystemRunningSettings.getInstance().getDefaultTestRunner());
-    }
-
-    private static TestRunnerItem from(GradleSystemRunningSettings.PreferredTestRunner value) {
-      return new TestRunnerItem(value);
+      if (value != null && !myProjectRef.isNull()) return null;
+      TestRunner defaultRunner =
+        myProjectRef.isNull() ? null : DefaultGradleProjectSettings.getInstance(myProjectRef.get()).getTestRunner();
+      return getText(defaultRunner);
    }

    @NotNull
-    private static String getText(@Nullable GradleSystemRunningSettings.PreferredTestRunner runner) {
-      if (runner == GradleSystemRunningSettings.PreferredTestRunner.PLATFORM_TEST_RUNNER) {
+    private String getText(@Nullable TestRunner runner) {
+      if (runner == TestRunner.PLATFORM) {
        return ApplicationNamesInfo.getInstance().getFullProductName();
      }
-      if (runner == GradleSystemRunningSettings.PreferredTestRunner.GRADLE_TEST_RUNNER) {
+      if (runner == TestRunner.GRADLE) {
        return "Gradle";
      }
-      if (runner == GradleSystemRunningSettings.PreferredTestRunner.CHOOSE_PER_TEST) {
+      if (runner == TestRunner.CHOOSE_PER_TEST) {
        return GradleBundle.message("gradle.preferred_test_runner.CHOOSE_PER_TEST");
      }
-      return GradleBundle.message("gradle.settings.text.use.application.default");
+      return GradleBundle.message("gradle.settings.text.use.default");
    }
  }
 }
@@ -0,0 +1,100 @@
+// Copyright 2000-2018 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.settings;
+
+import com.intellij.openapi.components.*;
+import com.intellij.openapi.project.Project;
+import org.jetbrains.annotations.ApiStatus;
+import org.jetbrains.annotations.NotNull;
+import org.jetbrains.annotations.Nullable;
+import org.jetbrains.plugins.gradle.service.settings.GradleSettingsService;
+
+/**
+ * {@link DefaultGradleProjectSettings} holds IDE project level settings defaults for gradle projects.
+ *
+ * @see GradleSettingsService
+ *
+ * @author Vladislav.Soroka
+ */
+@State(name = "DefaultGradleProjectSettings", storages = @Storage(StoragePathMacros.WORKSPACE_FILE))
+public class DefaultGradleProjectSettings implements PersistentStateComponent<DefaultGradleProjectSettings.MyState> {
+  private boolean myMigrated;
+  private boolean myDelegatedBuild;
+  @NotNull private TestRunner myTestRunner = TestRunner.PLATFORM;
+
+  @NotNull
+  public TestRunner getTestRunner() {
+    return myTestRunner;
+  }
+
+  void setTestRunner(@NotNull TestRunner testRunner) {
+    myTestRunner = testRunner;
+  }
+
+  public boolean isDelegatedBuild() {
+    return myDelegatedBuild;
+  }
+
+  public void setDelegatedBuild(boolean delegatedBuild) {
+    myDelegatedBuild = delegatedBuild;
+  }
+
+  @ApiStatus.ScheduledForRemoval(inVersion = "2019.2")
+  boolean isMigrated() {
+    return myMigrated;
+  }
+
+  @ApiStatus.ScheduledForRemoval(inVersion = "2019.2")
+  void setMigrated(boolean migrated) {
+    myMigrated = migrated;
+  }
+
+  @Nullable
+  @Override
+  public DefaultGradleProjectSettings.MyState getState() {
+    MyState state = new MyState();
+    state.delegatedBuild = myDelegatedBuild;
+    state.testRunner = myTestRunner;
+    state.isMigrated = myMigrated;
+    return state;
+  }
+
+  @Override
+  public void loadState(@NotNull MyState state) {
+    if (!state.isMigrated) {
+      migrateOldSettings();
+    }
+    else {
+      myDelegatedBuild = state.delegatedBuild;
+      myTestRunner = state.testRunner;
+    }
+    myMigrated = true;
+  }
+
+  @SuppressWarnings("deprecation")
+  private void migrateOldSettings() {
+    GradleSystemRunningSettings oldAppSettings = GradleSystemRunningSettings.getInstance();
+    myDelegatedBuild = oldAppSettings.isDelegatedBuildEnabledByDefault();
+    GradleSystemRunningSettings.PreferredTestRunner oldTestRunner = oldAppSettings.getDefaultTestRunner();
+    if (oldTestRunner == GradleSystemRunningSettings.PreferredTestRunner.PLATFORM_TEST_RUNNER) {
+      myTestRunner = TestRunner.PLATFORM;
+    }
+    else if (oldTestRunner == GradleSystemRunningSettings.PreferredTestRunner.GRADLE_TEST_RUNNER) {
+      myTestRunner = TestRunner.GRADLE;
+    }
+    else if (oldTestRunner == GradleSystemRunningSettings.PreferredTestRunner.CHOOSE_PER_TEST) {
+      myTestRunner = TestRunner.CHOOSE_PER_TEST;
+    }
+  }
+
+  @NotNull
+  public static DefaultGradleProjectSettings getInstance(@NotNull Project project) {
+    return ServiceManager.getService(project, DefaultGradleProjectSettings.class);
+  }
+
+  static class MyState {
+    public TestRunner testRunner = TestRunner.PLATFORM;
+    public boolean delegatedBuild;
+    @ApiStatus.ScheduledForRemoval(inVersion = "2019.2")
+    public boolean isMigrated;
+  }
+}
@@ -4,6 +4,7 @@ package org.jetbrains.plugins.gradle.settings;
 import com.intellij.openapi.externalSystem.service.execution.ExternalSystemJdkUtil;
 import com.intellij.openapi.externalSystem.settings.ExternalProjectSettings;
 import com.intellij.openapi.externalSystem.util.ExternalSystemApiUtil;
+import com.intellij.openapi.module.Module;
 import com.intellij.openapi.util.text.StringUtil;
 import com.intellij.util.SmartList;
 import com.intellij.util.ThreeState;
@@ -15,11 +16,19 @@ import org.jetbrains.annotations.NotNull;
 import org.jetbrains.annotations.Nullable;
 import org.jetbrains.plugins.gradle.model.data.BuildParticipant;
 import org.jetbrains.plugins.gradle.service.GradleInstallationManager;
+import org.jetbrains.plugins.gradle.service.settings.GradleSettingsService;

 import java.util.List;
 import java.util.Optional;

 /**
+ * {@link GradleProjectSettings} holds settings for the linked gradle project.
+ * These settings might have IDE project level defaults - {@link DefaultGradleProjectSettings}.
+ * Consider to use effective settings with {@link GradleSettingsService}.
+ *
+ * @see GradleSettingsService
+ * @see DefaultGradleProjectSettings
+ *
 * @author Denis Zhdanov
 */
 public class GradleProjectSettings extends ExternalProjectSettings {
@@ -36,7 +45,7 @@ public class GradleProjectSettings extends ExternalProjectSettings {
  @NotNull
  private ThreeState delegatedBuild = ThreeState.UNSURE;
  @Nullable
-  private GradleSystemRunningSettings.PreferredTestRunner testRunner;
+  private TestRunner testRunner;

  @Nullable
  public String getGradleHome() {
@@ -123,17 +132,10 @@ public class GradleProjectSettings extends ExternalProjectSettings {
    storeProjectFilesExternally = value;
  }

-  @Transient
-  @NotNull
-  public ThreeState getEffectiveDelegatedBuild() {
-    if (delegatedBuild == ThreeState.UNSURE) {
-      return ThreeState.fromBoolean(GradleSystemRunningSettings.getInstance().isDelegatedBuildEnabledByDefault());
-    }
-    return delegatedBuild;
-  }
-
  /**
-   * @return {@link ThreeState#UNSURE} means using application level configuration, see {@link GradleSystemRunningSettings#isDelegatedBuildEnabledByDefault()}
+   * Build/run mode for the gradle project.
+   * Consider to use effective settings using {@link GradleSettingsService#isDelegatedBuildEnabled(Module)}
+   * @return build/run mode, {@link ThreeState#UNSURE} means using IDE project level configuration, see {@link DefaultGradleProjectSettings#isDelegatedBuild()}
   */
  @OptionTag(value = "delegatedBuild", converter = ThreeStateConverter.class)
  @NotNull
@@ -142,33 +144,26 @@ public class GradleProjectSettings extends ExternalProjectSettings {
  }

  /**
-   * @param state {@link ThreeState#UNSURE} means using application level configuration, see {@link GradleSystemRunningSettings#isDelegatedBuildEnabledByDefault()}
+   * @param state {@link ThreeState#UNSURE} means using IDE project level configuration, see {@link DefaultGradleProjectSettings#isDelegatedBuild()}
   */
  public void setDelegatedBuild(@NotNull ThreeState state) {
    this.delegatedBuild = state;
  }

-  @Transient
-  @NotNull
-  public GradleSystemRunningSettings.PreferredTestRunner getEffectiveTestRunner() {
-    if (testRunner == null) {
-      return GradleSystemRunningSettings.getInstance().getDefaultTestRunner();
-    }
-    return testRunner;
-  }
-
  /**
-   * @return test runner option, "null" means using application level configuration, see {@link GradleSystemRunningSettings#getDefaultTestRunner()}
+   * Test runner option.
+   * Consider to use effective settings using {@link GradleSettingsService#getTestRunner(Module)}
+   * @return test runner option, "null" means using IDE project level configuration, see {@link DefaultGradleProjectSettings#getTestRunner()}
   */
  @Nullable
-  public GradleSystemRunningSettings.PreferredTestRunner getTestRunner() {
+  public TestRunner getTestRunner() {
    return testRunner;
  }

  /**
-   * @param testRunner null means using application level configuration, see {@link GradleSystemRunningSettings#getDefaultTestRunner()}
+   * @param testRunner null means using IDE project level configuration, see {@link DefaultGradleProjectSettings#getTestRunner()}
   */
-  public void setTestRunner(@Nullable GradleSystemRunningSettings.PreferredTestRunner testRunner) {
+  public void setTestRunner(@Nullable TestRunner testRunner) {
    this.testRunner = testRunner;
  }

@@ -6,6 +6,7 @@ import com.intellij.openapi.options.ConfigurationException;
 import com.intellij.openapi.ui.ComboBox;
 import com.intellij.ui.components.JBCheckBox;
 import org.jetbrains.annotations.Nls;
+import org.jetbrains.annotations.NotNull;
 import org.jetbrains.annotations.Nullable;
 import org.jetbrains.plugins.gradle.util.GradleBundle;

@@ -20,9 +21,14 @@ public class GradleRunnerConfigurable implements Configurable {
  private JBCheckBox myGradleAwareMakeCheckBox;
  private ComboBox myPreferredTestRunner;
  private static final TestRunnerItem[] TEST_RUNNER_ITEMS = new TestRunnerItem[]{
-    new TestRunnerItem(GradleSystemRunningSettings.PreferredTestRunner.PLATFORM_TEST_RUNNER),
-    new TestRunnerItem(GradleSystemRunningSettings.PreferredTestRunner.GRADLE_TEST_RUNNER),
-    new TestRunnerItem(GradleSystemRunningSettings.PreferredTestRunner.CHOOSE_PER_TEST)};
+    new TestRunnerItem(TestRunner.PLATFORM),
+    new TestRunnerItem(TestRunner.GRADLE),
+    new TestRunnerItem(TestRunner.CHOOSE_PER_TEST)};
+  private final DefaultGradleProjectSettings mySettings;
+
+  public GradleRunnerConfigurable(@NotNull DefaultGradleProjectSettings settings) {
+    mySettings = settings;
+  }

  @Nls
  @Override
@@ -39,18 +45,16 @@ public class GradleRunnerConfigurable implements Configurable {
  @Override
  public void apply() throws ConfigurationException {
    boolean gradleMakeEnabled = myGradleAwareMakeCheckBox.isSelected();
-    GradleSystemRunningSettings settings = GradleSystemRunningSettings.getInstance();
-    settings.setDelegatedBuildEnabledByDefault(gradleMakeEnabled);
-    GradleSystemRunningSettings.PreferredTestRunner preferredTestRunner = getSelectedRunner();
-    settings.setDefaultTestRunner(preferredTestRunner);
+    mySettings.setDelegatedBuild(gradleMakeEnabled);
+    TestRunner preferredTestRunner = getSelectedRunner();
+    mySettings.setTestRunner(preferredTestRunner);
  }

  @Override
  public void reset() {
-    GradleSystemRunningSettings settings = GradleSystemRunningSettings.getInstance();
-    final TestRunnerItem item = getItem(settings.getDefaultTestRunner());
+    TestRunnerItem item = getItem(mySettings.getTestRunner());
    myPreferredTestRunner.setSelectedItem(item);
-    boolean gradleMakeEnabled = settings.isDelegatedBuildEnabledByDefault();
+    boolean gradleMakeEnabled = mySettings.isDelegatedBuild();
    enableGradleMake(gradleMakeEnabled);
  }

@@ -62,12 +66,8 @@ public class GradleRunnerConfigurable implements Configurable {

  @Override
  public boolean isModified() {
-    GradleSystemRunningSettings uiSettings = new GradleSystemRunningSettings();
-    GradleSystemRunningSettings.PreferredTestRunner preferredTestRunner = getSelectedRunner();
-    uiSettings.setDefaultTestRunner(preferredTestRunner);
-    uiSettings.setDelegatedBuildEnabledByDefault(myGradleAwareMakeCheckBox.isSelected());
-    GradleSystemRunningSettings settings = GradleSystemRunningSettings.getInstance();
-    return !settings.equals(uiSettings);
+    return mySettings.isDelegatedBuild() != myGradleAwareMakeCheckBox.isSelected() ||
+           mySettings.getTestRunner() != getSelectedRunner();
  }

  private void createUIComponents() {
@@ -80,12 +80,12 @@ public class GradleRunnerConfigurable implements Configurable {
    myGradleAwareMakeCheckBox.setSelected(enable);
  }

-  private GradleSystemRunningSettings.PreferredTestRunner getSelectedRunner() {
+  private TestRunner getSelectedRunner() {
    final TestRunnerItem selectedItem = (TestRunnerItem)myPreferredTestRunner.getSelectedItem();
-    return selectedItem == null ? GradleSystemRunningSettings.PreferredTestRunner.CHOOSE_PER_TEST : selectedItem.value;
+    return selectedItem == null ? TestRunner.CHOOSE_PER_TEST : selectedItem.value;
  }

-  private static TestRunnerItem getItem(GradleSystemRunningSettings.PreferredTestRunner preferredTestRunner) {
+  private static TestRunnerItem getItem(TestRunner preferredTestRunner) {
    for (TestRunnerItem item : getItems()) {
      if (item.value == preferredTestRunner) return item;
    }
@@ -97,12 +97,12 @@ public class GradleRunnerConfigurable implements Configurable {
  }

  static class TestRunnerItem {
-    TestRunnerItem(GradleSystemRunningSettings.PreferredTestRunner value) {
+    TestRunner value;
+
+    TestRunnerItem(TestRunner value) {
      this.value = value;
    }

-    GradleSystemRunningSettings.PreferredTestRunner value;
-
    @Override
    public boolean equals(Object o) {
      if (this == o) return true;
@@ -5,19 +5,21 @@ import com.intellij.openapi.components.PersistentStateComponent;
 import com.intellij.openapi.components.ServiceManager;
 import com.intellij.openapi.components.State;
 import com.intellij.openapi.components.Storage;
-import com.intellij.openapi.externalSystem.util.ExternalSystemApiUtil;
-import com.intellij.openapi.module.Module;
-import com.intellij.openapi.project.Project;
 import com.intellij.util.xmlb.annotations.OptionTag;
 import org.gradle.internal.impldep.com.google.common.base.Objects;
 import org.jetbrains.annotations.ApiStatus;
 import org.jetbrains.annotations.NotNull;
 import org.jetbrains.annotations.Nullable;
+import org.jetbrains.plugins.gradle.service.settings.GradleSettingsService;

 /**
 * @author Vladislav.Soroka
+ *
+ * @deprecated use {@link GradleSettingsService}
 */
-@State(name = "GradleSystemRunningSettings", storages = @Storage("gradle.run.settings.xml"))
+@Deprecated
+@ApiStatus.ScheduledForRemoval(inVersion = "2019.2")
+@State(name = "GradleSystemRunningSettings", storages = @Storage(value = "gradle.run.settings.xml", deprecated = true))
 public class GradleSystemRunningSettings implements PersistentStateComponent<GradleSystemRunningSettings.MyState> {
  private boolean myDelegatedBuildEnabledByDefault;
  @NotNull private PreferredTestRunner myPreferredTestRunner = PreferredTestRunner.PLATFORM_TEST_RUNNER;
@@ -42,54 +44,12 @@ public class GradleSystemRunningSettings implements PersistentStateComponent<Gra
    myPreferredTestRunner = state.preferredTestRunner;
  }

-  @NotNull
-  public PreferredTestRunner getTestRunner(@NotNull Module module) {
-    String projectPath = ExternalSystemApiUtil.getExternalRootProjectPath(module);
-    if (projectPath == null) return myPreferredTestRunner;
-    return getTestRunner(module.getProject(), projectPath);
-  }
-
-  @NotNull
-  public PreferredTestRunner getTestRunner(@NotNull Project project, @NotNull String gradleProjectPath) {
-    GradleProjectSettings projectSettings = GradleSettings.getInstance(project).getLinkedProjectSettings(gradleProjectPath);
-    return projectSettings == null ? myPreferredTestRunner : projectSettings.getEffectiveTestRunner();
-  }
-
  @OptionTag("preferredTestRunner")
  @NotNull
  public PreferredTestRunner getDefaultTestRunner() {
    return myPreferredTestRunner;
  }

-  void setDefaultTestRunner(@NotNull PreferredTestRunner preferredTestRunner) {
-    myPreferredTestRunner = preferredTestRunner;
-  }
-
-  public boolean isDelegatedBuildEnabled(@NotNull Module module) {
-    String projectPath = ExternalSystemApiUtil.getExternalRootProjectPath(module);
-    if (projectPath == null) return false;
-    return isDelegatedBuildEnabled(module.getProject(), projectPath);
-  }
-
-  public boolean isDelegatedBuildEnabled(@NotNull Project project, @NotNull String gradleProjectPath) {
-    GradleProjectSettings projectSettings = GradleSettings.getInstance(project).getLinkedProjectSettings(gradleProjectPath);
-    if (projectSettings == null) return false;
-    return projectSettings.getEffectiveDelegatedBuild().toBoolean();
-  }
-
-  /**
-   * @deprecated use {@link #isDelegatedBuildEnabled(Module)} or {@link #isDelegatedBuildEnabled(Project, String)}
-   */
-  @Deprecated
-  @ApiStatus.ScheduledForRemoval(inVersion = "2019.1")
-  public boolean isUseGradleAwareMake() {
-    return myDelegatedBuildEnabledByDefault;
-  }
-
-  void setDelegatedBuildEnabledByDefault(boolean delegatedBuildEnabledByDefault) {
-    this.myDelegatedBuildEnabledByDefault = delegatedBuildEnabledByDefault;
-  }
-
  @OptionTag("useGradleAwareMake")
  public boolean isDelegatedBuildEnabledByDefault() {
    return myDelegatedBuildEnabledByDefault;
@@ -0,0 +1,9 @@
+// Copyright 2000-2018 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.settings;
+
+/**
+ * @author Vladislav.Soroka
+ */
+public enum TestRunner {
+  PLATFORM, GRADLE, CHOOSE_PER_TEST
+}
@@ -8,6 +8,7 @@ import com.intellij.internal.statistic.utils.getBooleanUsage
 import com.intellij.internal.statistic.utils.getEnumUsage
 import com.intellij.openapi.project.Project
 import org.jetbrains.plugins.gradle.settings.GradleSettings
+import org.jetbrains.plugins.gradle.service.settings.GradleSettingsService

 class GradleSettingsCollector : ProjectUsagesCollector() {
  override fun getGroupId() = "statistics.build.gradle.state"
@@ -24,8 +25,10 @@ class GradleSettingsCollector : ProjectUsagesCollector() {
    usages.add(getBooleanUsage("offlineWork", gradleSettings.isOfflineWork))
    usages.add(getBooleanUsage("showSelectiveImportDialogOnInitialImport", gradleSettings.showSelectiveImportDialogOnInitialImport()))

+    val settingsService = GradleSettingsService.getInstance(project)
    // project settings
    for (setting in gradleSettings.linkedProjectsSettings) {
+      val projectPath = setting.externalProjectPath
      usages.add(getYesNoUsage("isCompositeBuilds", setting.compositeBuild != null))
      usages.add(getEnumUsage("distributionType", setting.distributionType))
      usages.add(getEnumUsage("storeProjectFilesExternally", setting.storeProjectFilesExternally))
@@ -33,8 +36,8 @@ class GradleSettingsCollector : ProjectUsagesCollector() {
      usages.add(getBooleanUsage("createModulePerSourceSet", setting.isResolveModulePerSourceSet))
      usages.add(UsageDescriptor("gradleJvm." + ConvertUsagesUtil.escapeDescriptorName(setting.gradleJvm ?: "empty"), 1))
      usages.add(UsageDescriptor("gradleVersion." + setting.resolveGradleVersion().version, 1))
-      usages.add(getBooleanUsage("delegateBuildRun", setting.effectiveDelegatedBuild.toBoolean()))
-      usages.add(getEnumUsage("preferredTestRunner", setting.effectiveTestRunner))
+      usages.add(getBooleanUsage("delegateBuildRun", settingsService.isDelegatedBuildEnabled(projectPath)))
+      usages.add(getEnumUsage("preferredTestRunner", settingsService.getTestRunner(projectPath)))
    }
    return usages
  }
@@ -45,8 +45,9 @@ import org.intellij.lang.annotations.Language;
 import org.jetbrains.annotations.NonNls;
 import org.jetbrains.annotations.NotNull;
 import org.jetbrains.annotations.Nullable;
+import org.jetbrains.plugins.gradle.service.settings.GradleSettingsService;
 import org.jetbrains.plugins.gradle.settings.GradleSettings;
-import org.jetbrains.plugins.gradle.settings.GradleSystemRunningSettings;
+import org.jetbrains.plugins.gradle.settings.TestRunner;
 import org.junit.After;
 import org.junit.Before;
 import org.junit.Ignore;
@@ -381,11 +382,10 @@ public class GradleSettingsImportingTest extends GradleImportingTestCase {
        "}")
    );

-    GradleSystemRunningSettings settings = GradleSystemRunningSettings.getInstance();
-
+    GradleSettingsService settingsService = GradleSettingsService.getInstance(myProject);
    String projectPath = getCurrentExternalProjectSettings().getExternalProjectPath();
-    assertTrue(settings.isDelegatedBuildEnabled(myProject, projectPath));
-    assertEquals(GradleSystemRunningSettings.PreferredTestRunner.CHOOSE_PER_TEST, settings.getTestRunner(myProject, projectPath));
+    assertTrue(settingsService.isDelegatedBuildEnabled(projectPath));
+    assertEquals(TestRunner.CHOOSE_PER_TEST, settingsService.getTestRunner(projectPath));
  }

  @Test
@@ -9,7 +9,9 @@ import com.intellij.testFramework.fixtures.IdeaProjectTestFixture
 import com.intellij.testFramework.fixtures.IdeaTestFixtureFactory
 import com.intellij.util.ThreeState.*
 import com.intellij.util.ThrowableRunnable
-import org.jetbrains.plugins.gradle.settings.GradleSystemRunningSettings.PreferredTestRunner.*
+import org.jetbrains.plugins.gradle.service.settings.GradleSettingsService
+import org.jetbrains.plugins.gradle.settings.TestRunner.*
+import org.jetbrains.plugins.gradle.settings.GradleSystemRunningSettings.*
 import org.junit.After
 import org.junit.Before
 import org.junit.Test
@@ -18,7 +20,8 @@ class GradleSettingsTest : UsefulTestCase() {

  private lateinit var myTestFixture: IdeaProjectTestFixture
  private lateinit var myProject: Project
-  private lateinit var systemRunningSettings: GradleSystemRunningSettings
+  private lateinit var settingsService: GradleSettingsService
+  private lateinit var defaultSettings: DefaultGradleProjectSettings
  private lateinit var gradleProjectSettings: GradleProjectSettings

  @Before
@@ -28,8 +31,9 @@ class GradleSettingsTest : UsefulTestCase() {
    myTestFixture.setUp()
    myProject = myTestFixture.project

-    systemRunningSettings = GradleSystemRunningSettings.getInstance()
-    systemRunningSettings.loadState(GradleSystemRunningSettings.MyState())
+    defaultSettings = DefaultGradleProjectSettings.getInstance(myProject)
+    defaultSettings.loadState(DefaultGradleProjectSettings.MyState())
+    settingsService = GradleSettingsService.getInstance(myProject)
    gradleProjectSettings = GradleProjectSettings().apply { externalProjectPath = myProject.guessProjectDir()!!.path }
    GradleSettings.getInstance(myProject).linkProject(gradleProjectSettings)
  }
@@ -46,46 +50,51 @@ class GradleSettingsTest : UsefulTestCase() {
  fun `test delegation settings default configuration`() {
    // check test runner defaults
    assertNull(gradleProjectSettings.testRunner)
-    assertEquals(PLATFORM_TEST_RUNNER, gradleProjectSettings.effectiveTestRunner)
-    assertEquals(PLATFORM_TEST_RUNNER, systemRunningSettings.defaultTestRunner)
-    assertEquals(PLATFORM_TEST_RUNNER, systemRunningSettings.getTestRunner(myProject, gradleProjectSettings.externalProjectPath))
+    assertEquals(PLATFORM, defaultSettings.testRunner)
+    assertEquals(PLATFORM, settingsService.getTestRunner(gradleProjectSettings.externalProjectPath))

    // check build/run defaults
    assertEquals(UNSURE, gradleProjectSettings.delegatedBuild)
-    assertEquals(NO, gradleProjectSettings.effectiveDelegatedBuild)
-    assertFalse(systemRunningSettings.isDelegatedBuildEnabledByDefault)
-    assertFalse(systemRunningSettings.isDelegatedBuildEnabled(myProject, gradleProjectSettings.externalProjectPath))
+    assertFalse(defaultSettings.isDelegatedBuild)
+    assertFalse(settingsService.isDelegatedBuildEnabled(gradleProjectSettings.externalProjectPath))
+  }
+
+  @Test
+  fun `test old delegation settings migration`() {
+    val oldSettings = getInstance()
+    oldSettings.loadState(MyState().apply { useGradleAwareMake = true })
+    defaultSettings.loadState(DefaultGradleProjectSettings.MyState().apply { isMigrated = false })
+
+    assertEquals(PLATFORM, defaultSettings.testRunner)
+    assertTrue(defaultSettings.isDelegatedBuild)
+
+    oldSettings.loadState(MyState().apply { preferredTestRunner = PreferredTestRunner.GRADLE_TEST_RUNNER })
+    defaultSettings.loadState(DefaultGradleProjectSettings.MyState().apply { isMigrated = false })
+
+    assertEquals(GRADLE, defaultSettings.testRunner)
+    assertFalse(defaultSettings.isDelegatedBuild)
  }

  @Test
  fun `test delegation settings per linked project`() {
    // check test runner configuration change
    gradleProjectSettings.testRunner = CHOOSE_PER_TEST
-    assertEquals(CHOOSE_PER_TEST, gradleProjectSettings.testRunner)
-    assertEquals(CHOOSE_PER_TEST, gradleProjectSettings.effectiveTestRunner)
-    assertEquals(PLATFORM_TEST_RUNNER, systemRunningSettings.defaultTestRunner)
-    assertEquals(CHOOSE_PER_TEST, systemRunningSettings.getTestRunner(myProject, gradleProjectSettings.externalProjectPath))
+    assertEquals(PLATFORM, defaultSettings.testRunner)
+    assertEquals(CHOOSE_PER_TEST, settingsService.getTestRunner(gradleProjectSettings.externalProjectPath))

-    //// check app default change
-    systemRunningSettings.defaultTestRunner = GRADLE_TEST_RUNNER
+    //// check project default change
+    defaultSettings.testRunner = GRADLE
    assertEquals(CHOOSE_PER_TEST, gradleProjectSettings.testRunner)
-    assertEquals(CHOOSE_PER_TEST, gradleProjectSettings.effectiveTestRunner)
-    assertEquals(GRADLE_TEST_RUNNER, systemRunningSettings.defaultTestRunner)
-    assertEquals(CHOOSE_PER_TEST, systemRunningSettings.getTestRunner(myProject, gradleProjectSettings.externalProjectPath))
+    assertEquals(CHOOSE_PER_TEST, settingsService.getTestRunner(gradleProjectSettings.externalProjectPath))

    // check build/run configuration change
    gradleProjectSettings.delegatedBuild = YES
-    assertEquals(YES, gradleProjectSettings.delegatedBuild)
-    assertEquals(YES, gradleProjectSettings.effectiveDelegatedBuild)
-    assertFalse(systemRunningSettings.isDelegatedBuildEnabledByDefault)
-    assertTrue(systemRunningSettings.isDelegatedBuildEnabled(myProject, gradleProjectSettings.externalProjectPath))
+    assertFalse(defaultSettings.isDelegatedBuild)
+    assertTrue(settingsService.isDelegatedBuildEnabled(gradleProjectSettings.externalProjectPath))

-    //// check app default change
-    systemRunningSettings.isDelegatedBuildEnabledByDefault = true
+    //// check project default change
+    defaultSettings.isDelegatedBuild = true
    gradleProjectSettings.delegatedBuild = NO
-    assertEquals(NO, gradleProjectSettings.delegatedBuild)
-    assertEquals(NO, gradleProjectSettings.effectiveDelegatedBuild)
-    assertTrue(systemRunningSettings.isDelegatedBuildEnabledByDefault)
-    assertFalse(systemRunningSettings.isDelegatedBuildEnabled(myProject, gradleProjectSettings.externalProjectPath))
+    assertFalse(settingsService.isDelegatedBuildEnabled(gradleProjectSettings.externalProjectPath))
  }
 }