}

    @get:Inject
    abstract val fileSystemOperations: FileSystemOperations

    private
    var hasCleaned = false

    val logger = Logging.getLogger(CachesCleaner::class.java)

    fun cleanUpCaches() {
        synchronized(this) {
            if (hasCleaned) {
                return
            }
            logger.lifecycle("Cleaning up caches...")
            val homeDir = parameters.homeDir.get()

  suspend fun clients(): List<Client> =
    sslLabsApi.clients().map { userAgent ->
      Client(
        userAgent = userAgent.name,
        version = userAgent.version,
        platform = userAgent.platform,
        enabled = userAgent.suiteNames.map { SuiteId(null, it) },
      )
    }
}

suspend fun main() {
  val sslLabsClient =
    SslLabsClient(

import org.jetbrains.kotlin.gradle.tasks.KotlinCompile
import org.jetbrains.kotlin.load.java.JavaTypeEnhancementState
import org.jetbrains.kotlin.load.java.Jsr305Settings
import org.jetbrains.kotlin.load.java.ReportLevel


fun KotlinCompile.configureKotlinCompilerForGradleBuild() {
    compilerOptions {
        allWarningsAsErrors = true
        apiVersion = KotlinVersion.KOTLIN_2_2
        languageVersion = KotlinVersion.KOTLIN_2_2

  val sections: String,
  val ranges: String,
  val mappings: String,
) {
  /**
   * Returns true if the [codePoint] was applied successfully. Returns false if it was disallowed.
   */
  fun map(
    codePoint: Int,
    sink: BufferedSink,
  ): Boolean {
    val sectionsIndex = findSectionsIndex(codePoint)

    val rangesPosition = sections.read14BitInt(sectionsIndex + 2)

    val rangesLimit =

    OkHttpClient
      .Builder()
      .cache(
        Cache(
          directory = cacheDirectory,
          // 1 MiB.
          maxSize = 10L * 1024L * 1024L,
        ),
      ).build()

  fun run() {
    val request =
      Request
        .Builder()
        .url("http://publicobject.com/helloworld.txt")
        .build()

    val response1Body =
      client.newCall(request).execute().use {

  internal class StoriesTestProvider : SimpleProvider() {
    override fun arguments(): List<Any> = createStories(RAW_DATA)
  }

  private val bytesOut = Buffer()
  private val hpackWriter = Hpack.Writer(out = bytesOut)

  @ParameterizedTest
  @ArgumentsSource(StoriesTestProvider::class)
  fun testRoundTrip(story: Story) {
    assumeFalse(
      story === Story.MISSING,

            buildScanTags = listOf("Check"),
            subprojects = JsonBasedGradleSubprojectProvider(File("../.teamcity/subprojects.json")),
        )

    @Test
    fun `CompileAll parameters are correct`() {
        val linuxPaths =
            listOf(
                "%linux.java8.oracle.64bit%",
                "%linux.java11.openjdk.64bit%",
                "%linux.java17.openjdk.64bit%",

 * See the License for the specific language governing permissions and
 * limitations under the License.
 */

// https://www.eclipse.org/jetty/documentation/current/alpn-chapter.html#alpn-versions
private fun alpnBootVersionForPatchVersion(patchVersion: Int): String? =
  when (patchVersion) {
    in 0..24 -> "8.1.0.v20141016"
    in 25..30 -> "8.1.2.v20141202"
    in 31..50 -> "8.1.3.v20150130"
    in 51..59 -> "8.1.4.v20150727"

import okhttp3.MultipartBody
import okhttp3.OkHttpClient
import okhttp3.Request
import okhttp3.RequestBody.Companion.asRequestBody

class PostMultipart {
  private val client = OkHttpClient()

  fun run() {
    // Use the imgur image upload API as documented at https://api.imgur.com/endpoints/image
    val requestBody =
      MultipartBody
        .Builder()
        .setType(MultipartBody.FORM)

 */
class ApacheHttpClientTest {
  private val httpClient = HttpClients.createDefault()

  @StartStop
  private val server = MockWebServer()

  @AfterEach
  fun tearDown() {
    httpClient.close()
  }

  @Test
  fun get() {
    server.enqueue(
      MockResponse
        .Builder()
        .body("hello, Apache HttpClient 5.x")
        .build(),
    )