val config =
    LauncherConfig.builder()
      .enableTestExecutionListenerAutoRegistration(false)
      .enableTestEngineAutoRegistration(false)
      .enablePostDiscoveryFilterAutoRegistration(false)
      .addTestEngines(jupiterTestEngine)
      .addTestExecutionListeners(DotListener, summaryListener, treeListener)
      .build()
  val launcher: Launcher = LauncherFactory.create(config)

plugins {
    `kotlin-dsl`
}

group = "gradlebuild"

description = "Provides plugins used to create a Gradle plugin with Groovy or Kotlin DSL within build-logic builds"

dependencies {
    compileOnly("com.gradle:develocity-gradle-plugin")

    api(platform(projects.buildPlatform))

    implementation(projects.basics)
    implementation(projects.moduleIdentity)
    implementation("net.ltgt.gradle:gradle-errorprone-plugin:4.0.1")

### JVM platform

This is a platform that builds on the core and software platforms to add support for developing software that runs on the JVM.
This includes software that is implemented using Java, Kotlin or some other JVM language.

This platform provides specific support for Java, Groovy and Scala, and includes the foojay toolchain plugin.

### Extensibility platform

  AR_IMAGE="$AR_IMAGE_PATH:$target-$TAG"
  docker pull "$AR_IMAGE" || true
  # Due to some flakiness of resources pulled in the build, allow the docker
  # command to reattempt build a few times in the case of failure (b/302558736)
  set +e
  for i in $(seq 1 5)
  do
    docker build \
    --build-arg REQUIREMENTS_FILE=jax.requirements.txt \
    --target=$target \
    --cache-from "$AR_IMAGE" \
    -t "$AR_IMAGE" . && break
  done

fi

# TFCI Mac VM images do not have twine installed by default so we need to
# install it manually. We use Twine in nightly builds to upload Python packages
# to PyPI.
if [[ "$TFCI_MACOS_TWINE_INSTALL_ENABLE" == 1 ]]; then
  pip install twine==3.6.0
fi

# Scheduled nightly and release builds upload build artifacts (Pip packages,
# Libtensorflow archives) to GCS buckets. TFCI Mac VMs need to authenticate as

        if (jvmArgs.size > 1) {
            throw GradleException("gradle.properties and build-logic/gradle.properties have different org.gradle.jvmargs " +
                "which may cause two daemons to be spawned on CI and in IDEA. " +
                "Use the same org.gradle.jvmargs for both builds.")
        }
    }
}

fun readProperties(propertiesFile: File) = java.util.Properties().apply {

 */
package org.apache.maven.settings.building;

/**
 * Builds the effective settings from a user settings file, a project settings file
 * and/or a global settings file.
 *
 * @deprecated since 4.0.0, use {@link org.apache.maven.api.services.SettingsBuilder} instead
 */
@Deprecated(since = "4.0.0")
public interface SettingsBuilder {

    /**
     * Builds the effective settings of the specified settings files.
     *

 */
package org.apache.maven.toolchain.building;

/**
 * Builds the effective toolchains from a user toolchains file and/or a global toolchains file.
 *
 * @since 3.3.0
 * @deprecated since 4.0.0, use {@link org.apache.maven.api.services.ToolchainsBuilder} instead
 */
@Deprecated(since = "4.0.0")
public interface ToolchainsBuilder {

    /**
     * Builds the effective toolchains of the specified toolchains files.
     *

               MAVEN_GOAL='deploy'
           }
        }

        stage('Build / Unit Test') {
            String jdkName = jenkinsEnv.jdkFromVersion(buildOs, buildJdk)
            String mvnName = jenkinsEnv.mvnFromVersion(buildOs, buildMvn)
            try {
                withEnv(["JAVA_HOME=${ tool "$jdkName" }",

            checkout scm
        }

        def WORK_DIR=pwd()
        def MAVEN_GOAL='verify'

        stage('Build / Unit Test') {
            String jdkName = jenkinsEnv.jdkFromVersion(buildOs, buildJdk)
            String mvnName = jenkinsEnv.mvnFromVersion(buildOs, buildMvn)
            try {
                withEnv(["JAVA_HOME=${ tool "$jdkName" }",