when:
        withConnection { connection ->
            connection.notifyDaemonsAboutChangedPaths(toPaths(changedPaths))
        }

        then:
        toolingApi.daemons.daemons.empty
    }

    @TargetGradleVersion(">=6.1")
    def "changed paths need to be absolute"() {
        changedPaths = ["some/relative/path"]

        when:
        withConnection { connection ->

        super(delegate, modelMapping, adapter);
        InternalParameterAcceptingConnection connection = (InternalParameterAcceptingConnection) delegate;
        CancellationExceptionTransformer exceptionTransformer = CancellationExceptionTransformer.transformerFor(getVersionDetails());
        actionRunner = new ParameterizedActionRunner(connection, exceptionTransformer, getVersionDetails());
    }

    @Override

        InternalCancellableConnection connection = (InternalCancellableConnection) delegate;
        modelProducer = createModelProducer(connection, modelMapping, adapter, exceptionTransformer);
        actionRunner = new CancellableActionRunner(connection, exceptionTransformer, getVersionDetails());
    }

        Throwable failure = null;
        try {
            connection.dispatch(command);
            Result result = (Result) connection.receive();
            if (result instanceof Failure) {
                failure = ((Failure) result).getValue();
            }
            connection.dispatch(new Finished());
        } catch (Throwable e) {
            failure = e;
        }

project.logger.debug("debug log message");

task log {
    doLast {
        println "task log message"
    }
}
"""

        when:
        withConnection { ProjectConnection connection ->
            def build = connection.newBuild()
            build.forTasks("log")
            build.run()
        }

        then:
        !stdOutAndErr.stdOut.contains("log message")

import (
	"net"
	"time"
)

// DeadlineConn - is a generic stream-oriented network connection supporting buffered reader and read/write timeout.
type DeadlineConn struct {
	net.Conn
	readDeadline  time.Duration // sets the read deadline on a connection.
	writeDeadline time.Duration // sets the write deadline on a connection.
}

// Sets read deadline
func (c *DeadlineConn) setReadDeadline() {
	if c.readDeadline > 0 {

     * The following events trigger an end of input:
     * <ul>
     * <li>A {@link org.gradle.launcher.daemon.protocol.CloseInput} event received from the client.</li>
     * <li>When the client connection disconnects unexpectedly.</li>
     * <li>When the connection is closed using {@link #stop()}.</li>
     * </ul>
     *
     * Note: the end of input may be signalled from another thread before this method returns.
     *

        ProjectPublications publications = withConnection { connection ->
            connection.getModel(ProjectPublications)
        }

        then:
        publications.publications.empty
    }

    def "project without any configured publications"() {
        buildFile << "apply plugin: 'java'"

        when:
        ProjectPublications publications = withConnection { connection ->
            connection.getModel(ProjectPublications)

        withConnection { connection ->
            connection.newBuild().forTasks('help').run()
        }

        file("gradle.properties").writeProperties("org.gradle.java.home": jdk17.javaHome.absolutePath)
        withConnection { connection ->
            connection.newBuild().forTasks('help').run()
        }
    }

                test {
                    java {}
                    resources {}
                }
            }
        }

        when:
        IdeaProject project = withConnection { connection -> connection.getModel(IdeaProject.class) }
        IdeaModule module = project.children[0]
        IdeaContentRoot root = module.contentRoots[0]

        then:
        root.sourceDirectories.size() == 1