import org.gradle.internal.operations.CallableBuildOperation;
import org.gradle.internal.scan.UsedByScanPlugin;
import org.gradle.operations.dependencies.transforms.ExecutePlannedTransformStepBuildOperationType;
import org.gradle.operations.dependencies.transforms.PlannedTransformStepIdentity;
import org.gradle.operations.dependencies.variants.Capability;
import org.gradle.operations.dependencies.variants.ComponentIdentifier;

    Transformer<Serializable, Id> keyTransformer = new Transformer<Serializable, Id>() {
        @Override
        Serializable transform(Id id) {
            id.name
        }
    }
    Transformer<Result, Details> detailsToResult = new Transformer<Result, Details>() {
        @Override
        Result transform(Details details) {
            new Result(length: details.name.length())

                                                                                                           Transformer<E, Throwable> onDisabled,
                                                                                                           Transformer<E, Throwable> onError) {
            if (checkToHandleDisabledRepository(result, onDisabled)) {
                return;
            }

     * to tasks that use the new provider for input values.
     * </p>
     *
     * @param transformer The transformer to apply to values. May return {@code null}, in which case the provider will have no value.
     * @since 4.3
     */
    <S> Provider<S> map(Transformer<? extends @org.jetbrains.annotations.Nullable S, ? super T> transformer);

    /**

    }

    @ToBeFixedForIsolatedProjects(because = "allprojects, extensive cross-project access")
    def "artifact transforms are sensitive to empty directories by default"() {
        // Immutable artifact transforms are cached to the GradleUserHome,
        // so to avoid flakiness we need to request own GradleUserHome
        executer.requireOwnGradleUserHomeDir()

== Invalid use of an output property on an artifact transforms

This error indicates that you have annotated a property of an artifact transform with an output annotation, which is not the correct way to register outputs for artifact transforms.

To fix this problem, you must remove the property and use the `TransformOutputs` parameter instead.

        // Keep track of transformed artifacts as a given artifact may appear in multiple variants and configurations
        Map<LocalComponentArtifactMetadata, LocalComponentArtifactMetadata> transformedArtifacts = new HashMap<>();

        starter.startDaemon(options) >>> [client1, client2, client3]
        def stopMostPreferredClient = new Transformer<List<WorkerDaemonClient>, List<WorkerDaemonClient>>() {
            @Override
            List<WorkerDaemonClient> transform(List<WorkerDaemonClient> workerDaemonClients) {
                return workerDaemonClients[0..0]
            }
        }

        when:

    Serializer<ComponentMetadata> serializer
    InstantiatingAction<ComponentMetadataSupplierDetails> rule
    Transformer<ComponentMetadata, ComponentMetadataSupplierDetails> detailsToResult
    Transformer<ComponentMetadataSupplierDetails, ModuleVersionIdentifier> onCacheMiss
    CachePolicy cachePolicy

    ComponentMetadata result

    def setup() {
        def cacheBuilder

	return func() (State, error) {
		transformer, encObject, cacheKey, errGen := GenerateTransformer(ctx, string(uuid.NewUUID()), envelopeService, useSeed)
		if errGen != nil {
			return State{}, errGen
		}
		return State{
			Transformer:         transformer,
			EncryptedObject:     *encObject,
			UID:                 "panda",