// TODO(mlopatkin) figure out a nicer way of handling the presence of agent in the foreground daemon.
        //  Currently it is hard to have a proper "-javaagent:/path/to/jar" in clients that start the daemon, so all code deals with a boolean flag shouldApplyAgent instead.
        //  It is also possible to have the agent attached at runtime, without the flag, so flag checking is preferred.

import spock.lang.Specification

import java.util.function.BiConsumer

class BuildOperationFiringBuildWorkPreparerTest extends Specification {

    def "build operation provides execution plan when queries with all node types"() {
        def ti1 = TestTaskIdentities.create("t1", Task, Stub(ProjectInternal) {
            projectPath(_) >> { args -> Path.path(":" + args[0]) }
        })
        def t = Stub(LocalTaskNode) {

                .collect { (it as Requires).value() }
                .flatten() as List<Class>
        }

        PredicatesFile.checkValidCombinations(predicateClassNames, acceptedCombinations)
        // If all preconditions are met, we DON'T skip the tests
        specOfFeature.skipped |= !TestPrecondition.allSatisfied(annotation.value())
    }

            throw new ClassNotFoundException(
                "A pending instrumentation exception prevented loading a class " + className + " in " + classLoaderName, lastError);
        }
    }

    /**
     * Call this when an error occurs during class loading.
     * This method only records the error but doesn't throw any exceptions.

Gradle supports single and multi-project builds.

- For single-project builds, the settings file is optional.
- For multi-project builds, the settings file is mandatory and declares all subprojects.

[[sec:settings_file_script]]
== Settings script

The settings file is a script.
It is either a `settings.gradle` file written in Groovy or a `settings.gradle.kts` file in Kotlin.

            setProperty("returnDefaultValues", true)
        }
    }
    kotlinOptions {
        jvmTarget = "1.8"
    }
}

project.afterEvaluate {
    // Grab all build types and product flavors
    val buildTypes = android.buildTypes.map { type ->
        type.name
    }
    // When no product flavors defined, use empty

        new DslObject(options).getConventionMapping().map("outputDirectory", new Callable<File>() {
            @Override
            public File call() {
                return html.getOutputLocation().getAsFile().getOrNull();
            }
        });
    }

    @UsedByScanPlugin("test-retry")
    @Override

            new org.gradle.api.internal.artifacts.dsl.dependencies.ModuleFactoryDelegate(clientModule, this);
        moduleFactoryDelegate.prepareDelegation(configureClosure);
        configureClosure.call();
    }

    // region DependencyFactory methods

    @Override
    public ExternalModuleDependency create(CharSequence dependencyNotation) {

     */
    void registerWork(BuildOperationRef operation, AsyncWorkCompletion completion);

    /**
     * Blocks waiting for the completion of all items of asynchronous work associated with the provided build operation.
     * Only waits for work that has been registered at the moment the method is called.  In the event that there are failures in

        }
        return daemonLogsDir.listFiles().findAll { it.name.endsWith('.log') && !it.name.startsWith('hs_err') }.collect { daemonForLogFile(it) }
    }

    List<DaemonFixture> getVisible() {
        return registry.all.collect { daemonForLogFile(new File(daemonLogsDir, "daemon-${it.pid}.out.log")) }
    }

    DaemonFixture daemonForLogFile(File logFile) {
        def version = GradleVersion.version(version)