def binDir = file('fake-bin')

        then:
        def path
        if (OperatingSystem.current().windows) {
            path = ''
        } else {
            // Set up a fake bin directory, containing the things that the script needs, minus any java that might be in /usr/bin
            links.each { linkToBinary(it, binDir) }
            path = binDir.absolutePath
        }

    }

    def "can attach result dirs"() {
        def binDir = temporaryFolder.file("other")

        when:
        reportTask.testResults.from(binDir)

        then:
        reportTask.testResults.files as List == [binDir]
    }

    def test(String name) {
        def test = TestUtil.createTask(Test, project, name)

set -o errexit
set -o nounset
set -o pipefail

KUBE_ROOT=$(dirname "${BASH_SOURCE[0]}")/../..
source "${KUBE_ROOT}/hack/lib/util.sh"

CLEAN_PATTERNS=(
  "_tmp"
  "doc_tmp"
  "test/e2e/generated/bindata.go"
)

for item in "${CLEAN_PATTERNS[@]}"; do
  # Shellcheck wants the ":?" because of paranoia about 'rm -rf /'. It will
  # cause an error if unset, which is already true because of "nounset", but

        )

        val srcDir = newFolder("src")
        val binDir = newFolder("bin")

        // when:
        withSynchronousIO {
            buildPluginDependencySpecAccessorsFor(
                pluginDescriptorsClassPath = classPathOf(pluginsJar),
                srcDir = srcDir,
                binDir = binDir
            )
        }

        // then:

        this.hidden = hidden;
    }

    public void notifyFired(RuleBinder binder) {
        assert binder.isBound() : "RuleBinder must be in a bound state";
        for (ModelBinding inputBinding : binder.getInputBindings()) {
            ModelNodeInternal node = inputBinding.getNode();
            if (dependencies == null) {
                dependencies = new HashSet<>();
            }
            dependencies.add(node);

// for each version in the bundledVersions list.
func validateBundledVersions(bundledVersions SupportedVersions, binDir string) error {
	for _, v := range bundledVersions {
		for _, binaryName := range []string{"etcd", "etcdctl"} {
			fn := filepath.Join(binDir, fmt.Sprintf("%s-%s", binaryName, v))
			if _, err := os.Stat(fn); err != nil {

            "jvmName", "25.292-b01", "jvmVendor",
            "myArch"
        )
        installation.source >> "SourceSupplier"

        def binDir = new File(javaHome, "bin")
        if (binDir.mkdir()) {
            File javac = new File(binDir, OperatingSystem.current().getExecutableName('javac'))
            javac << 'dummy'
        }

        expect:

                        AnnotatedBindingBuilder<Object> binder = bind(itf);
                        if (key.getQualifier() instanceof String s) {
                            binder.annotatedWith(Names.named(s));
                        } else if (key.getQualifier() instanceof Annotation a) {
                            binder.annotatedWith(a);
                        }
                        binder.toProvider(() -> injector.getInstance(clazz));

internal
fun IO.buildVersionCatalogAccessorsFor(
    versionCatalogs: List<VersionCatalogAccessor>,
    srcDir: File,
    binDir: File
) {
    makeAccessorOutputDirs(srcDir, binDir, kotlinDslPackagePath)

    val baseFileName = "$kotlinDslPackagePath/VersionCatalogAccessors"
    val sourceFile = srcDir.resolve("$baseFileName.kt")

            LOGGER.debug("Found {} {} at {}", getDisplayName(), version.toString(), windowsKitDir);
            File binDir = new File(windowsKitDir, "bin/" + versionDir);
            File unversionedBinDir = new File(windowsKitDir, "bin");
            if (isValidComponentBinDir(binDir)) {
                T component = newComponent(windowsKitDir, binDir, version, discoveryType);
                found.add(component);