* @throws IllegalArgumentException if an argument is {@code null} or invalid
     * @see #build(ToolchainsBuilderRequest)
     */
    @Nonnull
    default ToolchainsBuilderResult build(
            @Nonnull Session session, @Nonnull Source globalToolchainsSource, @Nonnull Source userToolchainsSource) {
        return build(ToolchainsBuilderRequest.build(session, globalToolchainsSource, userToolchainsSource));
    }

        includedBuild("b2")

        when:
        def model = withConnection {
            it.getModel(GradleBuild)
        }

        then:
        def builds = model.includedBuilds
        builds.size() == 2
        builds.first().projects.first().buildTreePath == ":b1"
        model.projects.first().buildTreePath == ":"
    }

    @TargetGradleVersion('>=8.6')

        compile.dependencies.is(compile.dependencies)
    }

    def "builds and caches the configuration meta-data from the module descriptor"() {
        when:
        configuration("conf")

        then:
        metadata.getConfiguration("conf").transitive
        metadata.getConfiguration("conf").visible
    }

    def "builds and caches hierarchy for a configuration"() {
        given:
        configuration("a")

 * under the License.
 */
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
 */
public interface ToolchainsBuilder {

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

* Share build configuration logic between subprojects using convention plugins in `buildSrc`
* Run similar named tasks in all subprojects
* Run a task in a specific subproject
* Build, bundle and run the application

== Next steps

When your project grows, you might be interested in more details how to configure JVM projects, structuring multi-project builds and dependency management:

#### 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

[[sec:build_cache_enable]]
== Enable the Build Cache

By default, the build cache is not enabled. You can enable the build cache in a couple of ways:

Run with `--build-cache` on the command-line::
Gradle will use the build cache for this build only.
Put `org.gradle.caching=true` in your `gradle.properties`::
Gradle will try to reuse outputs from previous builds for all builds, unless explicitly disabled with `--no-build-cache`.

    @ToBeFixedForConfigurationCache
    def "builds IDE metadata artifacts in parallel"() {
        given:
        server.start()
        buildTestFixture.withBuildInSubDir()
        def buildA = singleProjectBuild("buildA") {
            buildFile << """
                apply plugin: 'java'
                apply plugin: 'idea'
            """
        }

        def included = ['buildB', 'buildC', 'buildD']

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

# This script builds a multi-arch kind node image
# Largely copied from https://github.com/kubernetes-sigs/kind/blob/2a1e9df91fd22d6ae5b91648b6c1a606ab4cdf30/hack/release/build/push-node.sh
# Example usage: `tools/build-kind-image.sh ~/go/src/k8s.io/kubernetes gcr.io/istio-testing/kind-node:v1.23.4`

set -uex

kdir="${1:?Kubernetes directory}"

env GO111MODULE=on

# Concurrent builds should succeed, even if they need to download modules.
go get ./x ./y
go build ./x &
go build ./y
wait

# Concurrent builds should update go.sum to the union of the hashes for the
# modules they read.
cmp go.sum go.sum.want

-- go.mod --
module golang.org/issue/26794

require (
	golang.org/x/text v0.3.0
	rsc.io/sampler v1.0.0
)
-- x/x.go --
package x