*
     * @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.
     */
    @Override
    void stop();

                "The Provider.forUseAtConfigurationTime method has been deprecated. " +
                    "This is scheduled to be removed in Gradle 9.0. " +
                    "Simply remove the call. " +
                    "Consult the upgrading guide for further information: " +
                    "https://docs.gradle.org/current/userguide/upgrading_version_7.html#for_use_at_configuration_time_deprecation")
        }

                    causes.add(it)
                }
            }
            return true
        }
    }
}


internal
class Summary(
    /**
     * Total of all problems, regardless of severity.
     */
    val problemCount: Int,

    /**
     * Total number of problems that are failures.
     */
    val failureCount: Int,

    /**

    /**
     * Class file bytes for Kotlin source name, if found.
     */
    fun classBytesFor(sourceName: String): ByteArray? =
        classBytesSupplierForSourceName(sourceName)?.let { it() }

    /**
     * All found class files bytes by Kotlin source name.
     */
    fun allClassesBytesBySourceName(): Sequence<Pair<String, ClassBytesSupplier>> =
        relevantClassPathFiles.asSequence()
            .flatMap { sourceNamesFrom(it) }

        ProviderFactory providers = project.getProviders();
        Provider<RegularFile> reportsDir = layout.file(providers.provider(() -> extension.getReportsDir()));
        task.getReports().all(action(report -> {
            report.getRequired().convention(!report.getName().equals("sarif"));
            report.getOutputLocation().convention(
                layout.getProjectDirectory().file(providers.provider(() -> {

 *
 * <p>
 * The following terms are worth distinguishing between:
 * </p>
 *
 * <dl>
 *     <dt>file system hierarchy</dt>
 *     <dd>A directory on the file system with all its descendants.</dd>
 *
 *     <dt>watchable hierarchies</dt>
 *     <dd>The list of file system hierarchies Gradle might want to watch if interesting content appears in the VFS for them.

            def tasksFile = file("tasks.txt")
            tasksFile.text = ''
            gradle.taskGraph.whenReady {
                allprojects {
                    tasks.matching { it.group == "mygroup" }.all {
                        tasksFile << path + '\\n'
                    }
                }
            }
        """
    }

    List<String> getCreatedTasks() {
        file("tasks.txt").readLines().sort()

     * String literals include surrounding quotes and have special symbols escaped.
     * The returned string can be used to generate call to a method that accepts varargs.
     *
     * @param cmd the command line elements to be converted
     * @return a comma-separated list of string literals
     */

            task.getPort().convention(webserverPort);

            task.dependsOn(extension.getRenderedDocumentation());
        });

        tasks.register("docs", task -> {
            task.setDescription("Generates all documentation");
            task.setGroup("documentation");
            task.dependsOn(extension.getRenderedDocumentation());
        });
    }

 *  </ul>
 *  <p>
 *  On serialization of an object of some type, the {@link org.gradle.internal.serialize.graph.codecs.BindingsBackedCodec bindings-backed composite codec}
 *  will query all bindings to find which one knows how to encode the type at hand,
 *  by invoking {@link org.gradle.internal.serialize.graph.codecs.Binding#encodingForType(java.lang.Class)} on each binding. If a binding supports the type,