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,

            config,
            buildOperationRunner,
            buildOperationProgressEmitter,
            temporaryFileProvider::createTemporaryFile,
            logStackTraces,
            !Boolean.getBoolean(REMOTE_CONTINUE_ON_ERROR_PROPERTY),
            packer,
            originMetadataFactory,
            stringInterner
        );
    }

    private static BuildCacheServicesConfiguration toConfiguration(

    @Override
    public void execute(DaemonCommandExecution execution) {
        if (execution.isSingleUseDaemon()) {
            execution.proceed();
            return;
        }

        if (Boolean.getBoolean(LogAndCheckHealth.HEALTH_MESSAGE_PROPERTY)) {
            logger.lifecycle(getStartBuildMessage());
        } else {
            // The default.
            logger.info(getStartBuildMessage());
        }