The new type [KeepAliveConfig] permits fine-tuning the keep-alive
options for TCP connections, via a new [TCPConn.SetKeepAliveConfig]

        openJarFile(jar).run {
            entries().asSequence()
                .filter { it.name.isClassFilePath }
                .map { kotlinSourceNameOf(it.name) }
        }

    private
    fun sourceNamesFromDir(dir: File): Sequence<String> =
        dir.walkTopDown()
            .filter { it.name.isClassFilePath }
            .map { kotlinSourceNameOf(normaliseFileSeparators(it.relativeTo(dir).path)) }

  // you made the request against.  If empty, it is defaulted.
  optional SubjectAccessReviewSpec spec = 2;

  // Status is filled in by the server and indicates whether the request is allowed or not
  // +optional
  optional SubjectAccessReviewStatus status = 3;
}

                val duration = it as JSONObject
                val testProject = duration["testProject"] as String
                duration.entries
                    .filter { (key, _) -> key != "testProject" }
                    .map { (osString, timeInMs) ->
                        val os = Os.valueOf(osString.uppercase(Locale.US))

# Set to "infinity" if you use the 'bootstrap.mlockall: true' option
# in fess.yml and 'MAX_LOCKED_MEMORY=unlimited' in ${packaging.env.file}
#LimitMEMLOCK=infinity

# Shutdown delay in seconds, before process is tried to be killed with KILL (if configured)
TimeoutStopSec=20

[Install]
WantedBy=multi-user.target

            val allSubprojectsInBucketJson = buckets.flatMap { it.subprojects.map { it.name } }.toSet()

            val allSubprojectsInModel = model.subprojects.getSubprojectsForFunctionalTest(testCoverage)
                .filter { onlyNativeSubprojectsForIntelMacs(testCoverage, it.name) }
                .map { it.name }
            val subprojectsInModelButNotInBucketJson = allSubprojectsInModel.toMutableList().apply { removeAll(allSubprojectsInBucketJson) }

}


abstract class DowngradeXmlApisRule : ComponentMetadataRule {
    override fun execute(context: ComponentMetadataContext) {
        context.details.allVariants {
            withDependencies {
                filter { it.group == "xml-apis" }.forEach {
                    it.version { require("1.4.01") }
                    it.because("Gradle has trouble with the versioning scheme and pom redirects in higher versions")
                }

data class PluginEntry(val pluginId: String, val implementationClass: String)


fun pluginEntriesFrom(jar: File): List<PluginEntry> = try {
    JarFile(jar, false).use { jarFile ->
        jarFile.entries().asSequence().filter {
            isGradlePluginPropertiesFile(it)
        }.map { pluginEntry ->
            val pluginProperties = jarFile.getInputStream(pluginEntry).use { Properties().apply { load(it) } }

fun main() {
  val knownTestFile = File("native-image-tests/src/main/resources/testlist.txt")
  val testSelector = DiscoverySelectors.selectPackage("okhttp3")
  val testClasses =
    findTests(listOf(testSelector))
      .filter { it.isContainer }
      .mapNotNull { (it as? ClassBasedTestDescriptor)?.testClass?.name }
      .filterNot { it in avoidedTests }
      .sorted()
      .distinct()
  knownTestFile.writeText(testClasses.joinToString("\n"))

   * enqueue messages followed by pongs, but this sends pongs followed by messages. Pongs are always
   * written in the order they were enqueued.
   *
   * If a frame cannot be sent - because there are none enqueued or because the web socket is not
   * connected - this does nothing and returns false. Otherwise this returns true and the caller