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 {

        val lexicalScope = positionInFakeFile.getResolutionScope(bindingContext)
        if (lexicalScope != null) {
            val compositeScope = KaCompositeScope.create(listOf(KaFe10ScopeLexical(lexicalScope, analysisContext)), token)
            return KaScopeContext(listOf(KaScopeWithKind(compositeScope, scopeKind, token)), collectImplicitReceivers(lexicalScope), token)
        }

val login = tasks.register<Exec>("login") {
    val loginProvider = providers.credentials(PasswordCredentials::class.java, "login")
    inputs.property("credentials", loginProvider)

    commandLine = listOf("sh", "login.sh")
    doFirst {
        val loginCredentials = loginProvider.get()
        standardInput = java.io.ByteArrayInputStream("${loginCredentials.username}\n${loginCredentials.password}".toByteArray())
    }
}

): List<R> {
    if (list.isEmpty()) {
        return noElementSplitFunction(expectedBucketNumber)
    }
    if (expectedBucketNumber == 1) {
        return listOf(smallElementAggregateFunction(list))
    }

    val expectedBucketSize = list.sumOf(toIntFunction) / expectedBucketNumber

    if (expectedBucketSize == 0) {

                delete { delete(transformDir) }
            }
    }
}


private
val scriptCacheDirNames =
    // TODO Remove gradle-kotlin-dsl* after a while
    listOf("scripts", "scripts-remapped", "gradle-kotlin-dsl", "gradle-kotlin-dsl-accessors", "kotlin-dsl")


private
fun scriptsCacheDirsUnder(cacheDir: File) =
    scriptCacheDirNames
        .map { File(cacheDir, it) }

}

dependencies {
    implementation("reporters:model-builder-plugin")
    implementation("org.gradle:gradle-tooling-api:8.6-milestone-1")
}

tasks.run.configure {
    args = listOf(
        project.gradle.rootBuild().rootProject.projectDir.absolutePath, // The path of the project (this project's root)
        ":sample-project:assemble"  // The executed task
    )
}

tasks.register("importBuild") {

import java.io.File

class GradleBuildToolRootProject(branch: VersionedSettingsBranch) : Project({
    val model = CIBuildModel(
        projectId = "Check",
        branch = branch,
        buildScanTags = listOf("Check"),
        subprojects = JsonBasedGradleSubprojectProvider(File("./subprojects.json"))
    )
    val gradleBuildBucketProvider = DefaultFunctionalTestBucketProvider(model, File("./test-buckets.json"))

public class KotlinByModulesResolutionScopeProvider : KotlinResolutionScopeProvider() {
    override fun getResolutionScope(module: KtModule): GlobalSearchScope {
        val allModules = topologicalSort(listOf(module)) {
            buildList {
                addAll(directDependsOnDependencies)
                addAll(directFriendDependencies)
                addAll(directRegularDependencies)
            }
        }

// tag::use-java-class[]
val readmeCheck by tasks.registering(com.example.ReadmeVerificationTask::class) {
    readme = layout.projectDirectory.file("README.md")
    readmePatterns = listOf("^## API$", "^## Changelog$")
}
// end::use-java-class[]

    assertThat(effectiveFragment, "fragment").isEqualTo(testData.fragment)
  }

  companion object {
    private val HTTP_URL_SCHEMES = listOf("http", "https")
    private val KNOWN_FAILURES =
      listOf(
        "Parsing: <http://example\t.\norg> against <http://example.org/foo/bar>",
        "Parsing: <http://f:0/c> against <http://example.org/foo/bar>",