Properties properties =
                loadResumptionFile(Paths.get(rootProject.getBuild().getDirectory()));
        applyResumptionProperties(request, properties);
    }

    @Override
    public void removeResumptionData(MavenProject rootProject) {
        Path resumeProperties = Paths.get(rootProject.getBuild().getDirectory(), RESUME_PROPERTIES_FILENAME);

         .mutable()
         .attribute(Attribute.of('foo', String), 'value')
"""
    }

    def "fails to generate metadata for component with no variants"() {
        given:
        settingsFile << "rootProject.name = 'root'"
        buildFile << """
            apply plugin: 'ivy-publish'

            group = 'group'
            version = '1.0'

            def comp = new TestComponent()

            publishing {

    public static final String DEFAULT_SCALA_PLATFORM_VERSION = "2.10.7";
    private final Project rootProject;

    public IdeaScalaConfigurer(Project rootProject) {
        this.rootProject = rootProject;
    }

    public void configure() {
        rootProject.getGradle().projectsEvaluated(new Action<Gradle>() {
            @Override
            public void execute(Gradle gradle) {

    GitHttpRepository repo = new GitHttpRepository(httpServer, 'dep', temporaryFolder.getTestDirectory())

    def setup() {
        httpServer.start()
        settingsFile << """
            rootProject.name = 'consumer'
            gradle.rootProject {
                configurations {
                    compile
                }
                dependencies {
                    compile 'test:test:1.2'
                }

        """
    }

    @ToBeFixedForConfigurationCache
    def "create visual studio solution for project without C++ component"() {
        when:
        settingsFile << """
            rootProject.name = 'app'
        """

        and:
        run "visualStudio"

        then:
        result.assertTasksExecuted(":visualStudio", ":appVisualStudioSolution")

        and:

        when:
        run 'init', '--dsl', scriptDsl.id as String

        then:
        dsl.assertGradleFilesGenerated()
        dsl.getSettingsFile().text.contains("rootProject.name = 'util'") || dsl.getSettingsFile().text.contains('rootProject.name = "util"')
        MavenConversionIntegrationTest.assertContainsPublishingConfig(dsl.getBuildFile(), scriptDsl)

        require(project == project.rootProject) {
            "$MODEL_NAME can only be requested on the root project, got $project"
        }
}


internal
object KotlinDslScriptsModelBuilder : AbstractKotlinDslScriptsModelBuilder() {

    override fun prepareParameter(rootProject: Project) = rootProject.parameterFromRequest()

        writeSpec {
            rootProject {
                dependencies {
                    conf 'org:included:1.0'
                    conf 'org:foo:1.0'
                }
            }
            includedBuild("includeBuild") {
                settings {
                    rootProjectName = 'included'
                }
                rootProject {
                    group = 'org'

    }

    def "can build debug and release variants of library"() {
        given:
        def lib = new SwiftLib()
        settingsFile << "rootProject.name = '${lib.projectName}'"
        lib.writeToProject(testDirectory)

        and:
        buildFile << """
            apply plugin: 'swift-library'
         """

        when:

            }
        """

        build1.settingsFile.setText("""
            pluginManagement {
                includeBuild("../${build2.buildName}")
            }
            rootProject.name = "${build1.buildName}"
        """)
        build1.buildFile.setText("""
            plugins {
                id("groovy-gradle-plugin")
                id("${build2.projectPluginId}")
            }