var visited: Boolean = false
    val dependencies: MutableSet<ClassDetails> = linkedSetOf()
    val outputClassFilename
        get() = "$outputClassName.class"
}


class PackagePatterns(givenPrefixes: Set<String>) {

    private
    val prefixes: MutableSet<String> = hashSetOf()

    private
    val names: MutableSet<String> = hashSetOf()

    init {

import java.io.File


abstract class IncubatingApiReportWorkAction : WorkAction<IncubatingApiReportParameter> {

    override fun execute() {
        try {
            val versionToIncubating = mutableMapOf<Version, MutableSet<IncubatingDescription>>()
            parameters.srcDirs.forEach { srcDir ->
                if (srcDir.exists()) {
                    val collector = CompositeVersionsToIncubatingCollector(
                        listOf(

import okio.Path
import okio.Sink

class FaultyFileSystem constructor(delegate: FileSystem?) : ForwardingFileSystem(delegate!!) {
  private val writeFaults: MutableSet<Path> = LinkedHashSet()
  private val deleteFaults: MutableSet<Path> = LinkedHashSet()
  private val renameFaults: MutableSet<Path> = LinkedHashSet()

  fun setFaultyWrite(
    file: Path,
    faulty: Boolean,
  ) {
    if (faulty) {
      writeFaults.add(file)

class BasicTrustRootIndex(vararg caCerts: X509Certificate) : TrustRootIndex {
  private val subjectToCaCerts: Map<X500Principal, Set<X509Certificate>>

  init {
    val map = mutableMapOf<X500Principal, MutableSet<X509Certificate>>()
    for (caCert in caCerts) {
      map.getOrPut(caCert.subjectX500Principal) { mutableSetOf() }.add(caCert)
    }
    this.subjectToCaCerts = map
  }

        }
    }

    private
    fun visitTree(
        classDetails: ClassDetails,
        classesDir: File,
        jarOutputStream: JarOutputStream,
        visited: MutableSet<ClassDetails>
    ) {

        if (!visited.add(classDetails)) {
            return
        }
        if (classDetails.visited) {
            val fileName = classDetails.outputClassFilename

        val rootProjectDir: DirectoryProperty
    }

    @get:Inject
    abstract val execOperations: ExecOperations

    private
    val suspiciousDaemons = ConcurrentHashMap<String, MutableSet<String>>()

    private
    val daemonPids = ConcurrentHashMap.newKeySet<String>()

    private
    val logger = Logging.getLogger(DaemonTracker::class.java)

    override fun close() {

            writer.println("</body></html>")
        }
    }

    private
    fun String.escape() = replace("<", "&lt;").replace(">", "&gt;")
}

        .allEnabledCipherSuites()
        .build()
    val allTlsVersions =
      ConnectionSpec.Builder(ConnectionSpec.MODERN_TLS)
        .allEnabledTlsVersions()
        .build()
    val set: MutableSet<Any> = CopyOnWriteArraySet()
    assertThat(set.add(ConnectionSpec.MODERN_TLS)).isTrue()
    assertThat(set.add(ConnectionSpec.COMPATIBLE_TLS)).isTrue()
    assertThat(set.add(ConnectionSpec.CLEARTEXT)).isTrue()

    /**
     * Returns the names of the request headers that need to be checked for equality when caching.
     */
    private fun Headers.varyFields(): Set<String> {
      var result: MutableSet<String>? = null
      for (i in 0 until size) {
        if (!"Vary".equals(name(i), ignoreCase = true)) {
          continue
        }

        val value = value(i)
        if (result == null) {

    val cloned = call.clone()
    cloned.enqueue(callback)
    val firstResponse = callback.await(request.url).assertSuccessful()
    val secondResponse = callback.await(request.url).assertSuccessful()
    val bodies: MutableSet<String?> = LinkedHashSet()
    bodies.add(firstResponse.body)
    bodies.add(secondResponse.body)
    assertThat(bodies).contains("abc")
    assertThat(bodies).contains("def")
  }

  @Test