rootProject.name = 'customizing-resolution-conditional-substitution-rule'
ext.projectNames = ["project1", "project2", "project3"]
include 'consumer'

projectNames.each { name ->
    if (isIncluded(name)) {
        println "project $name is INTERNAL to this build"
        include name
    } else {
        println "project $name is external to this build"
    }
}

def isIncluded(String projectName) {

rootProject.name = "customizing-resolution-conditional-substitution-rule"
val projectNames = listOf("project1", "project2", "project3")
include("consumer")

projectNames.forEach { name ->
    if (isIncluded(name)) {
        println("project $name is INTERNAL to this build")
        include(name)
    } else {
        println("project $name is external to this build")
    }
}

fun isIncluded(projectName: String): Boolean {

    def "can use work actions from multiple projects when running with --parallel"() {
        createDirs("project1", "project2", "project3", "project4", "project5")
        settingsFile << """
            include('project1')
            include('project2')
            include('project3')
            include('project4')
            include('project5')
        """
        buildFile << """

        solutionFile.projects = [project1, project2]

        then:
        generatedSolution.content ==
                """Microsoft Visual Studio Solution File, Format Version 11.00
# Visual C++ Express 2010

Project("{8BC9CEB8-8B4A-11D0-8D11-00A0C91BC942}") = "project1", "${project1.file.absolutePath}", "${getUUID(project1.file)}"
EndProject

        Modules(MavenHttpModule projectB, MavenHttpModule projectC, MavenHttpModule projectD) {
            this.projectB = projectB
            this.projectC = projectC
            this.projectD = projectD
        }

        def useLargeJars() {
            try (def file = new RandomAccessFile(projectB.artifact.file, "rw")) {
                file.setLength(100 * 1024) // not that large
            }
        }

    void "project dependency substituted with external dependency"() {
        createDirs("project1", "project2")
        runTask("idea", "include 'project1', 'project2'", """
allprojects {
    apply plugin: "java"
    apply plugin: "idea"
}

project(":project2") {
    ${mavenCentralRepository()}

    dependencies {
        implementation project(":project1")
    }

    configurations.all {

        projectA1.ivy.expectFileDownload()

        server.expectStat('/repo/group/projectB/')
        server.expectDirectoryList('/repo/group/projectB/')

        projectB1.ivy.expectMetadataRetrieve()
        projectB1.ivy.expectFileDownload()

        projectA1.jar.expectMetadataRetrieve()
        projectA1.jar.expectFileDownload()

        projectB1.jar.expectMetadataRetrieve()

    doLast {
        assert configurations.compile.collect { it.name } == ['projectA-1.2.jar', 'projectB-1.5.jar', 'projectC-2.0.jar']
    }
}
"""

        when:
        projectA.pom.expectGet()
        projectA.artifact.expectGet()
        projectB.pom.expectGet()
        projectB.artifact.expectGet()
        projectC.pom.expectGet()
        projectC.artifact.expectGet()

        then:

        buildDir.assertHasDescendants('projectA-1.2.jar')
        buildDir.file('projectA-1.2.jar').assertIsCopyOf(moduleA.artifactFile)

        when:
        moduleA.dependsOn('group', 'projectB', '9.1')
        moduleA.publishWithChangedContent()
        run 'retrieve'

        then:
        buildDir.assertHasDescendants('projectA-1.2.jar', 'projectB-9.1.jar')
        buildDir.file('projectA-1.2.jar').assertIsCopyOf(moduleA.artifactFile)

        MavenProject projectA = createSucceededMavenProject("A");
        MavenProject projectB = createFailedMavenProject("B");
        MavenProject projectC = createSkippedMavenProject("C");
        projectC.setDependencies(singletonList(toDependency(projectB)));
        executionResult.setTopologicallySortedProjects(asList(projectA, projectB, projectC));