val smokeIdeTestDistributionRuntimeOnly: Configuration by configurations
val ideStarter by configurations.creating {
    isVisible = false
    isCanBeConsumed = false
}

val unzipIdeStarter by tasks.registering(ProcessResources::class) {
    from(zipTree(ideStarter.elements.map { it.single() }))
    into(layout.buildDirectory.dir("ideStarter"))
}

plugins.withType<IdeaPlugin> {
    with(model) {
        module {

}

// publish plugin to local repository for integration testing -----------------
// See AbstractPluginTest
val localRepository = layout.buildDirectory.dir("repository")

val publishPluginsToTestRepository by tasks.registering {
    dependsOn("publishPluginMavenPublicationToTestRepository")
    val repoDir = localRepository // Prevent capturing the Gradle script instance for configuration cache compatibility

        container.newElement("c", [3], null)

        expect:
        container.conflicts.size() == 1
        container.popConflict().toString() == "a,b,c:3"
    }

    def "allows registering multiple elements with the same replacedBy before the replacedBy"() {
        container.newElement("a", [1], "c")
        container.newElement("b", [2], "c")
        container.newElement("c", [3], null)

 * See the License for the specific language governing permissions and
 * limitations under the License.
 */

/**
 * Provides classes, interfaces and annotations for registering and implementing artifact transforms.
 *
 * <p>
 *     To register an artifact transform, use {@link org.gradle.api.artifacts.dsl.DependencyHandler#registerTransform(java.lang.Class, org.gradle.api.Action)}.

----
====

== Registering a build service and connecting it to a task

To create a build service, you register the service instance using the link:{javadocPath}/org/gradle/api/services/BuildServiceRegistry.html#registerIfAbsent-java.lang.String-java.lang.Class-org.gradle.api.Action-[BuildServiceRegistry.registerIfAbsent()] method.
Registering the service does not create the service instance.

    }
}

// Register a code coverage report task to generate the aggregated report
val codeCoverageReport by tasks.registering(JacocoReport::class) {
    additionalClassDirs(classesPath.filter { it.isDirectory() })
    additionalSourceDirs(sourcesPath.incoming.artifactView { lenient(true) }.files)

 * Parameter names for the Gradle API.
 */
plugins {
    java
}

val apiDeclarationPropertiesFile = generatedPropertiesFileFor("gradle-api-declaration")

val apiDeclaration by tasks.registering(WriteProperties::class) {
    property("includes", PublicApi.includes.joinToString(":"))
    property("excludes", PublicApi.excludes.joinToString(":"))
    destinationFile = apiDeclarationPropertiesFile
}

To generate additional operators, extend the lists in this script. Note that
category names correspond to generated source file names, and should be
consistent with the original source files registering each operator. For example
since `REGISTER_OP("MatMul")` appears in ***core/math_ops.cc***, the "MatMul"
operator in the script should be in the "math" category, and it will be

import gradlebuild.kotlin.tasks.ParameterNamesIndex

plugins {
    id("gradlebuild.module-identity")
    java
}

val main = sourceSets.main.get()
val parameterNamesIndex by tasks.registering(ParameterNamesIndex::class) {
    sources.from(
        main.allJava.matching {
            include(PublicApi.includes)
            exclude(PublicApi.excludes)
        }
    )

    }
    integTestDistributionRuntimeOnly(project(":distributions-basics"))
}

val generateTestKitPackageList by tasks.registering(PackageListGenerator::class) {
    classpath.from(sourceSets.main.map { it.runtimeClasspath })
    outputFile = layout.buildDirectory.file("runtime-api-info/test-kit-relocated.txt")
}
tasks.jar {