def "receives progress while the model is building"() {
        file('build.gradle') << '''
System.out.println 'this is stdout'
System.err.println 'this is stderr'
'''

        when:
        def progress = withModel(GradleProject.class).progressMessages
        progress.removeLast()

        then:
        progress.size() >= 2
        progress.every { it }
    }

    def "tooling api reports failure to build model"() {

            allprojects { afterEvaluate {
                rootProject.description += project.path + ", "
            }}
        """

        when:
        def op = withModel(GradleProject.class)

        then:
        op.model.description.contains 'Projects configured: :, :api, :impl, :other'
    }

    def "running tasks takes advantage of configuration on demand"() {
        given:

    }

    @TargetGradleVersion(">=3.3")
    def "Does not execute tasks for included builds when generating IDE models"() {
        when:
        def modelOperation = withModel(modelType)
        def modelInstance = modelOperation.model

        then:
        modelType.isInstance modelInstance
        modelOperation.result.assertTasksExecuted()

        where:

            toolingApi.withConnection(cl)
        } catch (GradleConnectionException e) {
            caughtGradleConnectionException = e
            throw e
        }
    }

    ConfigurableOperation withModel(Class modelType, Closure cl = {}) {
        withConnection {
            def model = it.model(modelType)
            cl(model)
            new ConfigurableOperation(model).buildModel()
        }
    }

    private static Object or(Object node, Action<Object> withNode) {
        return logical(node, "or", withNode);
    }

    private static Object not(Object node, Action<Object> withNode) {
        return logical(node, "not", withNode);
    }

    private static Object addFilenames(Object node, Iterable<String> filenames, boolean caseSensitive) {
        GroovyObject groovyObject = (GroovyObject) node;

import org.gradle.internal.serialize.graph.readNonNull
import org.gradle.internal.serialize.graph.withCodec
import org.gradle.execution.plan.ActionNode


class ActionNodeCodec(
    private val userTypesCodec: Codec<Any?>,
) : Codec<ActionNode> {
    override suspend fun WriteContext.encode(value: ActionNode) {
        withCodec(userTypesCodec) {
            write(value.action)
        }
    }

import org.gradle.internal.serialize.graph.withCodec


/**
 * A codec that delegates to some more general codec, but only for a specific type
 */
class DelegatingCodec<T>(
    private val userTypesCodec: Codec<Any?>,
) : Codec<T> {

    override suspend fun WriteContext.encode(value: T) {
        // Delegate to the other codec
        withCodec(userTypesCodec) {
            write(value)
        }
    }

    }

    @Override
    public <R> R withNode(VfsRelativePath targetPath, CaseSensitivity caseSensitivity, NodeHandler<T, R> handler) {
        int childIndexWithCommonPrefix = findChildIndexWithCommonPrefix(targetPath, caseSensitivity);
        if (childIndexWithCommonPrefix >= 0) {
            Entry<T> entry = entries.get(childIndexWithCommonPrefix);
            return entry.withNode(targetPath, caseSensitivity, handler);
        }

    }

    @Override
    public <R> R withNode(VfsRelativePath targetPath, CaseSensitivity caseSensitivity, NodeHandler<T, R> handler) {
        return entry.withNode(targetPath, caseSensitivity, handler);
    }

    @Override
    public <RESULT> ChildMap<RESULT> invalidate(VfsRelativePath targetPath, CaseSensitivity caseSensitivity, InvalidationHandler<T, RESULT> handler) {

        return children.withNode(targetPath, caseSensitivity, new ChildMap.NodeHandler<T, Optional<MetadataSnapshot>>() {
            @Override
            public Optional<MetadataSnapshot> handleAsDescendantOfChild(VfsRelativePath pathInChild, T child) {