require(deflatedBytes.size == 0L)

    if (noContextTakeover) {
      deflater.reset()
    }

    deflaterSink.write(buffer, buffer.size)
    deflaterSink.flush()

    if (deflatedBytes.endsWith(EMPTY_DEFLATE_BLOCK)) {
      val newSize = deflatedBytes.size - LAST_OCTETS_COUNT_TO_REMOVE_AFTER_DEFLATION
      deflatedBytes.readAndWriteUnsafe().use { cursor ->
        cursor.resizeBuffer(newSize)
      }
    } else {

    return when {
      file.name.endsWith(".css") -> "text/css"
      file.name.endsWith(".gif") -> "image/gif"
      file.name.endsWith(".html") -> "text/html"
      file.name.endsWith(".jpeg") -> "image/jpeg"
      file.name.endsWith(".jpg") -> "image/jpeg"
      file.name.endsWith(".js") -> "application/javascript"
      file.name.endsWith(".png") -> "image/png"
      else -> "text/plain"
    }
  }

                    FileVisitResult.CONTINUE

                private
                fun Path.isClassFilePath() =
                    toString().endsWith(".class")

                private
                fun Path.isBuildReceipt() =
                    toString() == "/org/gradle/build-receipt.properties"

                private

    var pattern = pattern
    if (hostname.isNullOrEmpty() ||
      hostname.startsWith(".") ||
      hostname.endsWith("..")
    ) {
      // Invalid domain name.
      return false
    }
    if (pattern.isNullOrEmpty() ||
      pattern.startsWith(".") ||
      pattern.endsWith("..")
    ) {
      // Invalid pattern.
      return false
    }

private
val File.isClassPathArchive
    get() = extension.run { equals("jar", ignoreCase = true) || equals("zip", ignoreCase = true) }


private
val String.isClassFilePath
    get() = endsWith(classFileExtension)
        && !endsWith("package-info$classFileExtension")
        && !matches(compilerGeneratedClassFilePath)


private
const val classFileExtension = ".class"


private

                val sameParamCount = ktCtor.valueParameters.size == ctorParamTypes.size
                val sameParamTypes = sameParamCount && ctorParamTypes.mapIndexed { idx, paramType -> paramType.endsWith(ktCtor.valueParameters[idx].typeReference!!.text) }.all { it }
                sameName && sameParamCount && sameParamTypes
            }
            ?.isDocumentedAsSince(version) == true
    }

    private

        fun collectPackages(files: Iterable<Path>): Trie {
            val builder = Trie.Builder()
            for (file in files) {
                if (Files.exists(file)) {
                    if (file.fileName.toString().endsWith(".jar")) {
                        processJarFile(file, builder)
                    } else {
                        processDirectory(file, builder)
                    }
                }
            }

        cause
    )
}


private
fun isGradlePluginPropertiesFile(entry: JarEntry) = entry.run {
    !isDirectory && name.run { startsWith("META-INF/gradle-plugins/") && endsWith(".properties") }

    if (dir.asFile.isDirectory) {
        for (cacheDir in dir.asFile.listFiles()) {
            val cacheDirName = cacheDir.name
            if (!cacheDirName.startsWith(dirPrefix) || !cacheDirName.endsWith(dirSuffix)) {
                continue
            }
            val dirVersion = cacheDirName.removePrefix(dirPrefix).removeSuffix(dirSuffix)
            if (!dirVersion.matches(dirVersionPattern)) {

    assertThat(cache.hitCount()).isEqualTo(0)
  }

  private fun corruptMetadata(corruptor: (String) -> String) {
    val metadataFile =
      fileSystem.allPaths.find {
        it.name.endsWith(".0")
      }

    if (metadataFile != null) {
      val contents =
        fileSystem.read(metadataFile) {
          readUtf8()
        }

      fileSystem.write(metadataFile) {