with:
          payload: |
            {
              "text": "<https://github.com/gradle/gradle/${{ github.event.ref }}|[gradle/gradle#${{ github.event.ref }}]> has been pushed",
              "blocks": [
                {
                  "type": "section",
                  "text": {
                    "type": "mrkdwn",

     */
    <T> T useCache(Supplier<? extends T> action);

    /**
     * Performs some work against the cache. Acquires exclusive locks on the appropriate resources, so that the given action is the only action to execute across all processes (including this one). Releases the locks and all resources at the end of the action.

public interface WorkerControl {
    /**
     * Starts the worker process, blocking until successfully started.
     */
    WorkerProcess start();

    /**
     * Requests that the worker complete all work and stop. Blocks until the worker process has stopped.
     */
    ExecResult stop();

    /**
     * Requests that the worker stop immediately, without waiting for it to complete its work.
     */
    void stopNow();

 */
@ServiceScope(Scope.Global.class)
public interface MessagingClient {
    /**
     * Creates a connection to the given address. Blocks until the connection has been established.
     *
     * @param address The address to connect to.
     */
    ObjectConnection getConnection(Address address);

import org.gradle.internal.logging.events.ReadStdInEvent
import org.gradle.test.fixtures.concurrent.ConcurrentSpec

class StdInStreamTest extends ConcurrentSpec {
    def "read byte requests input from client and blocks until it is available"() {
        def dispatch = Mock(OutputEventListener)
        def stream = new StdInStream(dispatch)
        def text = "some text"
        def bytes = text.bytes

        when:
        async {

    /**
     * Receives a message from the client. Does not include any stdin messages. Blocks until a message is received or the connection is closed or the timeout is reached.
     *
     * @return null On end of connection or timeout.
     */
    Object receive(long timeoutValue, TimeUnit timeoutUnits);

    /**
     * Blocks until all handlers have been notified and any queued messages have been dispatched to the client.
     */

 * limitations under the License.
 */

plugins {
    id("gradlebuild.distribution.implementation-java")
    id("gradlebuild.publish-public-libraries")
}

description = "Monotonic clock implementation"

gradlebuildJava.usedInWorkers()

dependencies {
    api(projects.stdlibJavaExtensions)

import org.gradle.internal.service.scopes.ServiceScope;

@ServiceScope(Scope.Global.class)
public interface OutgoingConnector {
    /**
     * Creates a connection to the given address. Blocks until the connection with the peer has been established.
     *
     * @throws ConnectException when there is nothing listening on the remote address.
     */

    def userInputReader = new DefaultUserInputReader()

    def "blocks until user response received"() {
        expect:
        async {
            start {
                def result = userInputReader.readInput()
                instant.read
                assert result == response
            }
            thread.block()
            instant.put
            userInputReader.putInput(response)
        }

    id("gradlebuild.instrumented-project")
}

description = """Contains some base and shared classes for JVM language support, like AbstractCompile class and BaseForkOptions classes,
JVM-specific dependencies blocks and JVM test suite interfaces."""

errorprone {
    disabledChecks.addAll(
        "OverridesJavaxInjectableMethod", // 1 occurrences
        "UnusedMethod", // 1 occurrences
        "UnusedVariable", // 1 occurrences