fileSystemOperations.copy {
            from fileToReverse
            into parameters.destinationDir
            filter { String line -> line.reverse() }
        }
        if (Boolean.getBoolean("org.gradle.sample.showFileSize")) {
            println "Reversed ${fileToReverse.size()} bytes from ${fileToReverse.name}"
        }
    }
}

abstract class ReverseFiles extends SourceTask {

        System.setProperty("prop", "true")

        when:
        def result = Instrumented.getBoolean("prop", "consumer")

        then:
        result
        1 * listener.systemPropertyQueried("prop", "true", "consumer")
        0 * listener._

        when:
        result = Instrumented.getBoolean("not-set", "consumer")

        then:
        !result

public class ${testClassName} {

    private final ${productionClassName} production = new ${productionClassName}("value");

    @org.junit.Test
    public void testOne() throws Exception {
        if(Boolean.getBoolean("slowTasks")) {
            Thread.sleep(10);
        }
        for (int i = 0; i < 500; i++) {
            System.out.println("Some test output from ${testClassName}.testOne - " + i);

            }
        } else {
            this.configuration.add(configuration);
        }
    }

    public void fire() {
        if (!fired) {
            if (Boolean.getBoolean(TRACE)) {
                firedSentinel = new Exception("Project '" + project.getPath() + "' deferred configuration fired");
            }
            fired = true;
            try {

import org.gradle.internal.resource.ResourceLocation;
import org.gradle.util.internal.ConfigureUtil;

import javax.inject.Inject;
import java.io.File;
import java.net.URI;

import static java.lang.Boolean.getBoolean;

@NonExtensible
public class DefaultScriptHandler implements ScriptHandler, ScriptHandlerInternal {

    /**
     * If set to {@code true}, the buildscript's {@code classpath} configuration will not be reset after the

                implementation rootProject.orderedJar.outputs.files
            }
        '''
        buildFile << """
            task orderedJar(type: Jar) {
                def reverse = Boolean.getBoolean("reverse")
                inputs.property("reverse", reverse)
                if (reverse) {
                    from("external/d")
                    from("external/c")
                    from("external/b")

        this.heapEvents = new DefaultSlidingWindow<>(EVENT_WINDOW);
        this.nonHeapEvents = new DefaultSlidingWindow<>(EVENT_WINDOW);
        if (gcStrategy != GarbageCollectorMonitoringStrategy.UNKNOWN && !Boolean.getBoolean(DISABLE_POLLING_SYSTEM_PROPERTY)) {
            pollForValues();
        }
    }

    private void pollForValues() {

            import org.gradle.api.Project;
            import org.gradle.api.Plugin;
            
            public class GeneratedPlugin${i} implements Plugin<Project> {
                boolean reducedOutput = Boolean.getBoolean("reducedOutput");
                public void apply(Project project) {
                    ${maybeApplyNestedPluginCode(i)}
                    if (!reducedOutput) {

    @Rule
    PerformanceTestIdProvider performanceTestIdProvider = new PerformanceTestIdProvider()

    CrossBuildPerformanceTestRunner runner

    def setup() {
        Assume.assumeFalse(Boolean.getBoolean(CROSS_VERSION_ONLY_PROPERTY_NAME))
        runner = new CrossBuildPerformanceTestRunner(
                new GradleBuildExperimentRunner(gradleProfilerReporter, outputDirSelector),

        "-Dorg.gradle.configuration-cache.internal.load-after-store=${testWithLoadAfterStore()}"
    ].collect { it.toString() }

    static boolean testWithLoadAfterStore() {
        return !Boolean.getBoolean("org.gradle.configuration-cache.internal.test-disable-load-after-store")
    }

    IsolatedProjectsGradleExecuter(
        GradleDistribution distribution,
        TestDirectoryProvider testDirectoryProvider,