*/
@Incubating
public interface NativeComponentExtension {
    /**
     * The {@link NativeExecutableSpec} components produced by the build.
     */
    NamedDomainObjectContainer<NativeExecutableSpec> getExecutables();

    /**
     * Configure the {@link NativeExecutableSpec} components produced by the build.
     */
    void executables(Action<? super NamedDomainObjectContainer<? super NativeExecutableSpec>> action);

        signing {
            sign configurations.produced
        }

        then:
        configurations.signatures.artifacts.size() == 3
        signProduced.signatures.every { it in configurations.signatures.artifacts }
    }

    def "sign configuration with custom type"() {
        def signingTasks
        when:
        signing {
            signingTasks = sign configurations.produced

# standard vendor if it doesn't).

# vendor directory produced for workspace, workspace mode
# runs in mod=vendor
go work vendor
cmp vendor/modules.txt want_workspace_modules_txt
go list -f {{.Dir}} example.com/b
stdout $GOPATH[\\/]src[\\/]vendor[\\/]example.com[\\/]b

# vendor directory produced for workspace, module mode
# runs in mod=readonly
env GOWORK=off
go list -f {{.Dir}} example.com/b

        Try<T> getResult();

        /**
         * The origin metadata of the result.
         *
         * If a previously produced output was reused in some way, the reused output's origin metadata is returned.
         * If the output was produced in this request, then the current execution's origin metadata is returned.
         */
        Optional<OriginMetadata> getOriginMetadata();
    }

# RUN: not tfcompile --graph=%s --config=%s.config.pbtxt --mlir_components=None 2>&1 | FileCheck -check-prefix=OLD %s

# Checks the error message produced by tfcompile with mlir_component
# Checks that source debug information is used in the output error message and
# the node x_y_sum = Add

            INVOCATION_COUNT.incrementAndGet()
            outputs.file(new File(inputArtifact.get().asFile, SELECTED_PATH))
            outputs.file("produced-file-1.txt").text = "produced1"
            outputs.dir(inputArtifact)
            outputs.file("produced-file-2.txt").text = "produced2"
        }
    }

			t.Fatalf("hash of the same object (%q) produced different results: %d vs %d", toString(tc()), hash1, hash2)
		}
		for i := 0; i < 100; i++ {
			hasher2 := adler32.New()

			DeepHashObject(hasher1, tc())
			hash1a := hasher1.Sum32()
			DeepHashObject(hasher2, tc())
			hash2a := hasher2.Sum32()

			if hash1a != hash1 {

 *
 * A task can depend upon another task's outcome (PASS vs. FAIL), outputs (the files they produce) or both. A verification
 * failure represents the case where a task has a failed outcome, but has still produced valid output files for consumption.
 * Tasks that only depend on the other task's outputs are allowed to execute. Tasks that depend on both the outcome and

            }
        })));
    }

    /**
     * Returns the import library produced by this task. Defaults to the directory containing the runtime file and is not defined when no import library will be produced.
     *
     * @since 4.4
     */
    @Optional @OutputFile
    public RegularFileProperty getImportLibrary() {
        return importLibrary;
    }

/**
 * The result of running a single transform action on a single input artifact.
 *
 * The result of running a transform is a list of outputs.
 * There are two kinds of outputs for a transform:
 * - Produced outputs in the workspace. Those are relative paths depending on the workspace root, independent of the input artifact.