if err == nil && j.Type == DeleteType && v < 2 {
		if val, ok := j.DeleteMarker.MetaSys[ReservedMetadataPrefixLower+ReplicationTimestamp]; ok {
			tm, err := time.Parse(time.RFC3339Nano, string(val))
			if err == nil {
				j.DeleteMarker.MetaSys[ReservedMetadataPrefixLower+ReplicationTimestamp] = []byte(tm.UTC().Format(time.RFC3339Nano))
			}
		}
		if val, ok := j.DeleteMarker.MetaSys[ReservedMetadataPrefixLower+ReplicaTimestamp]; ok {

  /** Returns a request that transforms `request` to be all uppercase.  */
  private fun uppercaseRequest(request: Request): Request {
    val uppercaseBody: RequestBody =
      object : ForwardingRequestBody(request.body) {
        @Throws(IOException::class)
        override fun writeTo(sink: BufferedSink) {
          delegate().writeTo(uppercaseSink(sink).buffer())

 * proxy in a list, looking up a subsequent one may succeed.
 */
internal class FailedPlan(
  e: Throwable,
) : RoutePlanner.Plan {
  val result = RoutePlanner.ConnectResult(plan = this, throwable = e)

  override val isReady = false

  override fun connectTcp() = result

  override fun connectTlsEtc() = result

  override fun handleSuccess() = error("unexpected call")

	globalServiceFreezeMu.Lock()
	// Close when we reach 0
	globalServiceFreezeCnt--
	if globalServiceFreezeCnt <= 0 {
		// Set to a nil channel.
		var _ch chan struct{}
		if val := globalServiceFreeze.Swap(_ch); val != nil {
			if ch, ok := val.(chan struct{}); ok && ch != nil {
				// Close previous non-nil channel.
				xioutil.SafeClose(ch)
			}
		}
		globalServiceFreezeCnt = 0 // Don't risk going negative.
	}

     */
    abstract val collectedInformation: Serializable

    interface Params : BuildServiceParameters {
        val monitoredTaskPaths: SetProperty<String>
    }

    override fun onFinish(event: FinishEvent) {
        if (event !is TaskFinishEvent) {
            return
        }

        val taskPath = event.descriptor.taskPath
        if (shouldInclude(taskPath)) {

        require(project.rootProject == project) { "This plugin should be applied to root project!" }
        val globalExtension = project.extensions.create<TestFilesCleanupBuildServiceRootExtension>("testFilesCleanupRoot")
        project.gradle.taskGraph.whenReady {
            val testFilesCleanupService = project.gradle.sharedServices.registerIfAbsent("testFilesCleanupBuildService", TestFilesCleanupService::class.java) {

  private class TlsFallbackScsvDisabledSSLSocket(
    socket: SSLSocket,
  ) : DelegatingSSLSocket(socket) {
    override fun setEnabledCipherSuites(suites: Array<String>) {
      val enabledCipherSuites = mutableListOf<String>()
      for (suite in suites) {
        if (suite != TLS_FALLBACK_SCSV) {
          enabledCipherSuites.add(suite)
        }
      }

    /**
     * @return the minor
     */
    int getMinor() {
        return this.minor;
    }

    void setOption(final String key, final Object val) throws DcerpcException {
        if (key.equals("endpoint")) {
            this.endpoint = val.toString();
            final String lep = this.endpoint.toLowerCase(Locale.ENGLISH);
            if (lep.startsWith("\\pipe\\")) {

    logWithTime("cacheConditionalHit: $cachedResponse")
  }

  private fun logWithTime(message: String) {
    val timeMs = TimeUnit.NANOSECONDS.toMillis(System.nanoTime() - startNs)
    logger.log("[$timeMs ms] $message")
  }

  open class Factory
    @JvmOverloads
    constructor(
      private val logger: HttpLoggingInterceptor.Logger = HttpLoggingInterceptor.Logger.DEFAULT,
    ) : EventListener.Factory {

    name == candidateName.replace(".*\\$".toRegex(), "") // strip outer class names

private
val SINCE_REGEX = Regex("""@since ([^\s]+)""")

private
fun BodyDeclaration<*>.getSince(): String? =
    comment?.orElse(null)?.content?.let { content ->
        SINCE_REGEX.find(content)?.groupValues?.get(1)
    }


private
val FieldDeclaration.fieldName: String
    get() = variables.first().name.asString()