assertIsTransform()
            descriptor.transformer.displayName == "BrokenTransform"
            descriptor.subject.displayName == transformTarget()
            !successful
            failures.size() == 1
            failures[0].description.contains("intentional failure")
        }
    }

    def "does not report transform progress events when TRANSFORM operations are not requested"() {
        given:

                    return "Transformer with $provider"
                }
            }
            transform.provider = new FlatMapProvider(Providers.of("value"), transform)
            return transform.provider
        }
    }

    static class FlatMapProviderCircularChainEvaluationTest extends CircularChainEvaluationSpec<String> implements UsesStringProperty {
        @Override

	return t.seen&isRTL != 0
}

// Reset implements transform.Transformer.
func (t *Transformer) Reset() { *t = Transformer{} }

// Transform implements transform.Transformer. This Transformer has state and
// needs to be reset between uses.
func (t *Transformer) Transform(dst, src []byte, atEOF bool) (nDst, nSrc int, err error) {
	if len(dst) < len(src) {
		src = src[:len(dst)]

 */

package org.gradle.operations.dependencies.transforms;

import org.gradle.internal.operations.BuildOperationType;
import org.gradle.internal.scan.NotUsedByScanPlugin;

/**
 * A {@link BuildOperationType} for executing a scheduled transform step.
 * <p>
 * Encompasses the execution of a transform step node.
 * The node runs only one transform, though possibly on multiple files.
 *
 * @since 8.1
 */

        }

        @Override
        public void applyTo(String value, BuildLayoutParameters settings, Origin origin) {
            Transformer<File, String> resolver = new BasicFileResolver(settings.getCurrentDir());
            settings.setGradleUserHomeDir(resolver.transform(value));
        }
    }

    public static class ProjectDirOption extends StringBuildOption<BuildLayoutParameters> {
        public ProjectDirOption() {

    private final PropertiesTransformer transformer;
    private Properties properties;

    protected PropertiesPersistableConfigurationObject(PropertiesTransformer transformer) {
        this.transformer = transformer;
    }

    @Override
    public void load(InputStream inputStream) throws Exception {
        properties = new Properties();

    }

    def "transforms pre-compiled header spec to contain generated source files" () {
        given:
        def tempDir = tmpDirProvider.createDir("temp")
        def pchSourceDir = tempDir.createDir("pchGenerated")
        def headerDir = tmpDirProvider.createDir("headers")
        def sourceFile = headerDir.createFile("test.h")

            }
        }
    }

    private String checkBaselineVersion(Transformer<Boolean, BaselineVersion> fails, Transformer<String, BaselineVersion> provideMessage) {
        def failed = false
        def failure = new StringBuilder()
        baselineVersions.values().each { it ->
            String message = provideMessage.transform(it)
            if (fails.transform(it)) {
                failed = true
                failure.append message

                    to.attribute(artifactType, 'size')
                }
            }

            def transformed = configurations.compile.incoming.artifactView { attributes.attribute(artifactType, 'size') }.files

            task resolve(type: ShowFilesTask) {
                inFiles.from(transformed)
            }

            abstract class MakeSize implements TransformAction<None> {
                @InputArtifact

        output.count("Transforming") == 2
    }

    def "cross-build dependency with transform in another build"() {
        given:
        def buildB = multiProjectBuild('buildB', ['app', 'lib'])
        buildB.buildFile << """
            import org.gradle.api.artifacts.transform.TransformParameters

            subprojects {