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

kube::util::ensure-temp-dir

# Get vendored packages dependencies
# Use -deps flag to include transitive dependencies
go list -mod=vendor -test -tags other   -e -deps -json ./vendor/... > "${KUBE_TEMP}/deps_other.json"

        mavenRepo.module("org", "foo", '1.0')
            .dependsOn("org", "baz", '1.0').publish()
        mavenRepo.module("org", "baz", '1.0')
            .dependsOn("org", "baz-transitive", "1.0").publish()
        mavenRepo.module("org", "baz-transitive", "1.0").publish()

        // "org:bar:1.0" -> "org:foo:1.1" (no further transitive deps)

        and:
        outputs.recompiledFile sourceFile
    }

    @ToBeFixedForConfigurationCache
    def "recompiles source file when transitively imported header file is changed"() {
        given:
        def transitiveHeaderFile = file("src/main/headers/transitive.h") << """
           // Dummy header file
"""
        otherHeaderFile << """
            #import "${transitiveHeaderFile.name}"
"""

[[sec:disabling_resolution_transitive_dependencies]]
== Disabling transitive resolution

By default Gradle resolves all transitive dependencies specified by the dependency metadata.
Sometimes this behavior may not be desirable e.g. if the metadata is incorrect or defines a large graph of transitive dependencies.

    @Unroll("Selects direct=#expectedDirectVariant, transitive=[#expectedTransitiveVariantA, #expectedTransitiveVariantB], leaf=#expectedLeafVariant making sure dependency attribute value doesn't leak to transitives")
    def "Attribute value on dependency only affects selection of this dependency (using component metadata rules)"() {
        given:
        repository {
            def modules = ['direct', 'transitive', 'leaf']

// go.mod file:
//
//  1. (The import invariant.) Every module that provides a package transitively
//     imported by any package or test in the main module is included as a root.
//     This follows by induction from (1) and (3) above. Transitively-imported
//     packages loaded during this invocation are marked with pkgInAll (1),
//     and by hypothesis any transitively-imported packages loaded in previous
//     invocations were already roots in rs (3).

- however if you are a library, adding <<dependency_downgrade_and_exclude.adoc#sec:excluding-transitive-deps,exclusions>> may prevent consumers from working properly, because they would exercise a path of the code that you don't

            }
        """
        transitive = mavenHttpRepo.module("test", "transitive", "1.0")
        direct = mavenHttpRepo.module("test", "direct", "1.0")
        direct.dependsOn(transitive)
    }

    // region With Gradle Module Metadata
    def "direct has GMM and no sources or javadoc jars"() {
        transitive.withModuleMetadata()
        transitive.publish()
        direct.withModuleMetadata()

However, it is easy to miss that some dependencies are upgraded because of a transitive dependency.
In the example above, if `1.1` was a version used in your build script and `1.3` a version brought transitively, you could use `1.3` without actually noticing.

                    }
                }
            """
            file("transitive/build.gradle") << """
                plugins {
                    id 'java'
                }
            """
            file("transitive/src/main/java/transitive/Powerize.java").java """
                package transitive;

                public class Powerize {
                    int pow(int x, int y) {