}
        """
        when:
        succeeds("resolve")
        then:
        file("build/alternative").assertDoesNotExist()
        file("build/output").assertExists()
    }

    def "can depend on two configurations from the same project"() {
        file("producer/build.gradle") << """
            configurations {
                conf {
                    assert canBeConsumed

//
// Usage:
//
//	go run ../../mkzip.go ../../zoneinfo.zip
//
// We use this program instead of 'zip -0 -r ../../zoneinfo.zip *' to get
// a reproducible generator that does not depend on which version of the
// external zip tool is used or the ordering of file names in a directory
// or the current time.
package main

import (
	"archive/zip"
	"bytes"
	"flag"
	"fmt"
	"hash/crc32"

This library is the canonical location of the Kubernetes API definition. Most likely interaction with this repository is as a dependency of client-go.

It is published separately to avoid diamond dependency problems for users who
depend on more than one of `k8s.io/client-go`, `k8s.io/apimachinery`,
`k8s.io/apiserver`...

## Recommended Use

We recommend using the go types in this repo. You may serialize them directly to
JSON.

        }
    }

    private static String errorMessageFor(String factory) {
        return "Unable to create secure " + factory + ", please make sure that your build does not depend on an old XML parser.";
    }

    private XmlFactories() {}

Once they leave experimental, these APIs should be considered stable for use
by external clients.

These headers are in a separate directory to make it obvious to clients which
headers they should depend on, and which headers are implementation details.
Separating these public headers by directory also allow future programmatic
checks to ensure that TF public headers only `#include` other public TF headers.

Sometimes, you might want to depend on the output of a specific task within another project rather than the entire project.
However, explicitly declaring a task dependency from one project to another is discouraged as it introduces unnecessary coupling between tasks.

# a test that exits with an I/O stream held open
# should fail after a reasonable delay, not wait forever.
# (As of the time of writing, that delay is 10% of the timeout,
# but this test does not depend on its specific value.)

[short] skip 'runs a test that hangs until its WaitDelay expires'

! go test -v -timeout=1m .

	# After the test process itself prints PASS and exits,

cd "${KUBE_ROOT}"

# Check for any module that is not main or staging and depends on main or staging
bad_deps=$(go mod graph | grep -vE "^k8s.io/(kubernetes|${staging_repos_pattern})" | grep -E "\sk8s.io/(kubernetes|${staging_repos_pattern})" || true)
if [[ -n "${bad_deps}" ]]; then
  echo "Found disallowed dependencies that transitively depend on k8s.io/kubernetes or staging modules:"
  echo "${bad_deps}"
  exit 1
fi

}

gradlebuildJava.usedInWorkers()

description = """JVM-specific test infrastructure, including support for bootstrapping and configuring test workers
and executing tests.
Few projects should need to depend on this module directly. Most external interactions with this module are through the
various implementations of WorkerTestClassProcessorFactory.
"""

dependencies {
    api(projects.stdlibJavaExtensions)

reports for all tasks that implement the link:{groovyDslPath}/org.gradle.api.reporting.Reporting.html[Reporting] interface from _all projects_ in the build. It is typically only applied to the root project.

The `buildDashboard` task does not depend on any other tasks. It will only aggregate the reporting tasks that are independently being executed as part of the build run. To generate the build dashboard, simply include this task in the list of tasks to execute. For example, “`gradle buildDashboard...