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)

    public static final ArchRule there_are_no_package_cycles =
        SlicesRuleDefinition.slices().assignedFrom(GRADLE_SLICE_ASSIGNMENT)
            .should()
            .beFreeOfCycles()
            // Some projects exclude all classes, that is why we allow empty here
            .allowEmptyShould(true);

    private static class JavaProjectScopeServices implements ServiceRegistrationProvider {
        @Provides
        public ToolchainToolFactory createToolFactory(ExecActionFactory generator) {
            // TODO should we create all tools via this factory?
            return new ToolchainToolFactory() {
                @Override
                public <T> T create(Class<T> toolType, JavaToolchain toolchain) {

        } finally {
            registering.remove(build);
        }
    }

    private void makeSubstitutionsAvailableFor(BuildState build, Set<BuildState> seen) {
        // A build can see all the builds that it includes
        if (!seen.add(build)) {
            return;
        }
        boolean added = registering.add(build);
        try {

import java.util.Set;
import java.util.concurrent.ConcurrentHashMap;

import static org.gradle.tooling.internal.provider.runner.ClientForwardingBuildOperationListener.toOperationResult;

/**
 * Transform listener that forwards all receiving events to the client via the provided {@code ProgressEventConsumer} instance.
 *
 * @since 5.1
 */

        def result = lister.list(location)

        then:
        result == null

        1 * delegate.list(location) >> null
    }

    def expectListBuildOperation() {
        1 * buildOperationRunner.call(_) >> { CallableBuildOperation action ->
            def descriptor = action.description().build()
            assert descriptor.name == "List https://location/"
            assert descriptor.displayName == "List https://location/"