* limitations under the License.
 */
package org.gradle.initialization;

import org.gradle.plugin.use.internal.PluginsAwareScript;

public abstract class SettingsScript extends PluginsAwareScript {
    @Override
    public String toString() {
        return getScriptTarget().toString();
    }

            serviceRegistryFactory,
            gradle,
            classLoaderScope,
            baseClassLoaderScope,
            scriptHandlerFactory.create(settingsScript, classLoaderScope),
            settingsDir,
            settingsScript,
            startParameter
        );
        Map<String, Object> properties = gradleProperties.getProperties();

        applySettingsScript(settingsScript, settings);
        LOGGER.debug("Timing: Processing settings took: {}", settingsProcessingClock.getElapsed());
        return state;
    }

    private void applySettingsScript(TextResourceScriptSource settingsScript, final SettingsInternal settings) {

        1 * settingsProcessor.process(gradle, buildLayout, classLoaderScope, startParameter) >> state
        _ * state.settings >> settings
        1 * settings.settingsScript >> settingsScript
        1 * settingsScript.displayName >> "foo"

        then:
        settingsHandler.findAndLoadSettings(gradle) == state
    }

        this.settingsDir = settingsDir;
    }

    @Override
    public ScriptSource getSettingsScript() {
        return settingsScript;
    }

    public void setSettingsScript(ScriptSource settingsScript) {
        this.settingsScript = settingsScript;
    }

    @Override
    @Inject
    public abstract ProviderFactory getProviders();

    @Inject

 * limitations under the License.
 */

package org.gradle.configuration;

import org.gradle.api.internal.SettingsInternal;
import org.gradle.groovy.scripts.BasicScript;
import org.gradle.initialization.SettingsScript;

public class SettingScriptTarget extends DefaultScriptTarget {
    public SettingScriptTarget(SettingsInternal target) {
        super(target);
    }

    @Override
    public String getId() {

        when (scriptContext) {
            is DeclarativeScriptContext.UnknownScript -> SchemaNotBuilt

            is DeclarativeScriptContext.SettingsScript -> {
                require(scriptContext is LoadedSettingsScriptContext) { "A ${LoadedSettingsScriptContext::class.simpleName} is needed to build the settings schema" }
                InterpretationSequenceAvailable(

import org.gradle.plugins.ide.AbstractIdeIntegrationTest

class AbstractEclipseIntegrationTest extends AbstractIdeIntegrationTest {
    protected ExecutionResult runEclipseTask(settingsScript = "rootProject.name = 'root'", buildScript) {
        runTask("eclipse", settingsScript, buildScript)
    }

    protected File getProjectFile(Map options) {
        getFile(options, ".project")
    }

    protected File getClasspathFile(Map options) {

    @Before
    void setUp() {
        executer.withRepositoryMirrors()
    }

    protected ExecutionResult runTask(taskName, settingsScript = "rootProject.name = 'root'", buildScript) {
        def settingsFile = file("settings.gradle")
        settingsFile << settingsScript

        def buildFile = file("build.gradle")
        buildFile << buildScript

        return executer.withTasks(taskName).run()
    }

        }

        @Override
        void beforeScenario(ScenarioContext context) {
            def projectTestDir = new TestFile(projectDir)
            def settingsScript = projectTestDir.file('settings.gradle')
            settingsScript.text = """
                    buildscript {
                        repositories {
                            maven {
                                name 'gradleInternalRepository'