def setup() {
        def mavenRepo = new MavenFileRepository(file('maven-repo'))
        mavenRepo.module('org.example', 'lib', '1.0').publish()

        settingsFile << 'rootProject.name = "root"'
        buildFile << """
            plugins {
                id 'java-library'
            }

            repositories {
                maven {

        def util = mavenHttpRepo.module("org.external", "external-util").publish().allowAll()
        mavenHttpRepo.module("org.external", "external-lib")
            .dependsOn(util)
            .publish()
            .allowAll()
        mavenHttpRepo.module("org.external", "external-lib2")
            .dependsOn(util)
            .withModuleMetadata()
            .publish()
            .allowAll()

    implementation(project(":plugins-java-library"))
    implementation(project(":plugins-jvm-test-suite"))
    implementation(project(":plugin-use"))
    implementation(project(":process-services"))
    implementation(project(":publish"))
    implementation(project(":testing-jvm"))
    implementation(project(":toolchains-jvm"))

    implementation(libs.asm)
    implementation(libs.guava)

    testImplementation(project(":file-collections"))

plugins {
    id("gradlebuild.distribution.api-java")
    id("gradlebuild.publish-public-libraries")
    id("gradlebuild.shaded-jar")
}

description = "Gradle Tooling API - the programmatic API to invoke Gradle"

gradlebuildJava.usedInToolingApi()

tasks.named<Jar>("sourcesJar") {
    // duplicate package-info.java because of split packages
    duplicatesStrategy = DuplicatesStrategy.EXCLUDE
}

shadedJar {

            ProjectBuilderImpl.stop(project)
        }
    }

    def "can resolve remote dependencies"() {
        def repo = new MavenHttpRepository(server, mavenRepo)
        repo.module("org.gradle", "a", "1.0").publish().allowAll()
        server.start()

        when:
        project = ProjectBuilder.builder().build()
        project.with {
            repositories {
                maven { url repo.uri }
            }

			_, err = target.stanConn.PublishAsync(target.args.Subject, data, nil)
		} else {
			err = target.stanConn.Publish(target.args.Subject, data)
		}
	} else {
		if target.jstream != nil {
			_, err = target.jstream.Publish(target.args.Subject, data)
		} else {
			err = target.natsConn.Publish(target.args.Subject, data)
		}
	}
	return err
}

}

# Move into the directory of the script
cd "$(dirname "$0")"

if is_continuous_or_release || [[ -z "$KOKORO_BUILD_ID" ]]; then
  # A continuous job is the only one to publish to latest
  TAG="latest-multi-python"
else
  # If it is a change, grab a good tag for iterative builds
  if [[ -z "${KOKORO_GITHUB_PULL_REQUEST_NUMBER}" ]]; then

  done
done

# Build apko base image, which isn't part of our image building tool
APKO_ARCHES="$(echo "${DOCKER_ARCHITECTURES:-arm64,amd64}" | sed 's/linux\///g')"
# shellcheck disable=SC2086

        ]
    }

    def "order of entries in the effective classpath stays the same as in the original classpath"() {
        given:
        withIncludedBuild()
        mavenRepo.module("org", "commons", "3.2.1").publish()
        buildFile << """
            import java.nio.file.Paths

            buildscript {
                repositories {
                    maven { url "${mavenRepo.uri}" }
                }

    def setup() {
        def mavenRepo = new MavenFileRepository(file("maven-repo"))
        mavenRepo.module("org.example", "example-lib", "1.0").publish()

        createDirs("sub")
        settingsFile <<
        """rootProject.name = 'root'
           include 'sub'
        """

        buildFile <<
        """apply plugin: 'java'