String getConsumerProjectPath();

    /**
     * The component identifier of the transformed artifact.
     */
    ComponentIdentifier getComponentId();

    /**
     * Full set of attributes of the artifact before the transform.
     */
    Map<String, String> getSourceAttributes();

    /**
     * Target attributes of the transformed artifact.
     * <p>

        then:
        result == transformed

        1 * attributeMatcher.matches(_, _, _) >> Collections.emptyList()
        1 * consumerProvidedVariantFinder.findTransformedVariants(variants, requestedAttributes) >> transformedVariants
        1 * factory.asTransformed(variant, transformedVariants[0].getTransformedVariantDefinition(), dependenciesResolverFactory, transformedVariantFactory) >> transformed
        0 * attributeMatcher._
    }

    def attachesLogLevelToTextOutputEvent() {
        StyledTextOutputEvent event = Mock()
        StyledTextOutputEvent transformed = Mock()

        when:
        listener.onOutput(event)

        then:
        1 * event.withLogLevel(LogLevel.LIFECYCLE) >> transformed
        1 * target.onOutput(transformed)
        0 * target._
    }

    def doesNotChangeLogLevelWhenEventAlreadyHasALogLevel() {

                    Files.exists(transformedDir.resolve("transformed/${INSTRUMENTATION_CLASSPATH_MARKER.fileName}")) ||
                    Files.exists(transformedDir.resolve("transformed/$ANALYSIS_OUTPUT_DIR/${INSTRUMENTATION_CLASSPATH_MARKER.fileName}")) ||

            ivySerializationHelper.writeRealisedConfigurationsData(encoder, transformed, deduplicationDependencyCache);
        } else if (transformed instanceof RealisedMavenModuleResolveMetadata) {
            mavenSerializationHelper.writeRealisedVariantsData(encoder, transformed);
            mavenSerializationHelper.writeRealisedConfigurationsData(encoder, transformed, deduplicationDependencyCache);
        } else {

        when:
        transformer.add { it + ' transformed'}

        then:
        transformer.transform('original') == 'original transformed'
    }

    def 'uses original object when Closure returns null'() {
        when:
        transformer.add { null }

        then:
        transformer.transform('original') == 'original'
    }

    def 'uses original object when Closure returns object of unexpected type'() {

            if (!JarUtil.isMultiReleaseJarManifest(parsedManifest)) {
                // If the original JAR is not multi-release, we don't need the manifest in the transformed JAR at all.
                return;
            }
            isMultiReleaseJar = true;

            // We want the transformed JAR to also be a proper multi-release JAR.
            // To do so it must have the "Multi-Release: true" attribute.

package org.gradle.api.internal.provider;

import org.gradle.api.Transformer;
import org.gradle.api.provider.Provider;

import javax.annotation.Nullable;

public class FlatMapProvider<S, T> extends AbstractMinimalProvider<S> {
    private final ProviderInternal<? extends T> provider;
    private final Transformer<? extends Provider<? extends S>, ? super T> transformer;

        String destFileName = source.getName();
        File receipt = new File(destDir, destFileName + ".receipt");
        File transformed = new File(destDir, destFileName);

        // Avoid file locking overhead by checking for the receipt first.
        if (receipt.isFile()) {
            return transformed;
        }

        final File lockFile = new File(destDir, destFileName + ".lock");

        }
        Object[] transformed = new Object[args.length];
        for (int i = 0; i < args.length; i++) {
            Object arg = args[i];
            Class<?> type = types[i].getTheClass();
            if (type.isEnum() && arg instanceof CharSequence) {
                transformed[i] = toEnumValue(Cast.uncheckedNonnullCast(type), arg);
            } else {
                transformed[i] = args[i];
            }
        }