/**
     * {@inheritDoc}
     */
    @Override
    CopySpec filter(Closure closure);

    /**
     * {@inheritDoc}
     */
    @Override
    CopySpec filter(Transformer<@org.jetbrains.annotations.Nullable String, String> transformer);

    /**
     * {@inheritDoc}
     */
    @Override
    CopySpec expand(Map<String, ?> properties);

    /**
     * {@inheritDoc}
     */
    @Override

 * See the License for the specific language governing permissions and
 * limitations under the License.
 */

package org.gradle.workers.internal

import org.gradle.api.Transformer
import org.gradle.api.logging.LogLevel
import org.gradle.internal.event.DefaultListenerManager
import org.gradle.internal.event.ListenerManager
import org.gradle.internal.logging.LoggingManagerInternal

            assertTrue event.eventTime == 999
            assertTrue event.displayName == "Transform started"
            assertTrue event.descriptor.displayName == 'Transform'
            assertTrue event.descriptor.transformer.displayName == 'SomeTransform'
            assertTrue event.descriptor.subject.displayName == 'artifact "foo.jar"'
        }
    }

    def "convert to TransformSuccessResult"() {
        given:

        1 * action.execute() >> execResult
        _ * execResult.assertNormalExitValue()
    }

    Transformer transformer(constant) {
        transformer { constant }
    }

    Transformer transformer(Closure closure) {
        new Transformer() {
            String transform(original) {
                closure.call(original)
            }
        }
    }

        buildFile """
interface Transformer {}

class Impl implements Transformer {}

class MyTask extends DefaultTask {
    public void transform(Class<? extends Transformer> c) {
        logger.lifecycle("transform(Class)")
    }

    public void transform(Transformer t) {
        logger.lifecycle("transform(Transformer)")
    }
}

task print(type: MyTask) {

        when:
        spec.filter { it.length() > 10 ? null : it }

        then:
        spec.copyActions.size() == 1
    }

    def 'filter with Transformer'() {
        when:
        spec.filter(new Transformer<String, String>() {
            @Override
            String transform(String input) {
                input.length() > 10 ? null : input
            }
        })

	if newObj != nil {
		newObj = newObj.DeepCopyObject()
	}

	// Allow any configured transformers to update the new object
	for _, transformer := range i.transformers {
		newObj, err = transformer(ctx, newObj, oldObj)
		if err != nil {
			return nil, err
		}
	}

	return newObj, nil
}

// wrappedUpdatedObjectInfo allows wrapping an existing objInfo and

        if (dataClass == null) {
            // check transformer name
            if (!getName().equals(accessResultData.getTransformerName())) {
                throw new CrawlerSystemException("Transformer is invalid. Use " + accessResultData.getTransformerName()
                        + ". This transformer is " + getName() + ".");
            }

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

    ComponentMetadata result

    def setup() {
        def cacheBuilder

 * See the License for the specific language governing permissions and
 * limitations under the License.
 */

package org.gradle.api.internal.artifacts.repositories;

import org.gradle.api.Transformer;
import org.gradle.api.artifacts.dsl.RepositoryHandler;
import org.gradle.api.artifacts.repositories.ArtifactRepository;
import org.gradle.api.artifacts.repositories.AuthenticationContainer;