client = null,
          carrier = this,
          socket = socket,
        )
      socket.source.timeout().timeout(readTimeoutMillis.toLong(), TimeUnit.MILLISECONDS)
      socket.sink.timeout().timeout(writeTimeoutMillis.toLong(), TimeUnit.MILLISECONDS)
      tunnelCodec.writeRequest(nextRequest.headers, requestLine)
      tunnelCodec.finishRequest()
      val response =
        tunnelCodec

  @BeforeEach
  fun setUp() {
    platform.assumeNotOpenJSSE()
    server.protocolNegotiationEnabled = false
    val loggingFileSystem = LoggingFilesystem(fileSystem)
    cache = buildCache("/cache/".toPath(), Int.MAX_VALUE.toLong(), loggingFileSystem)
    client =
      clientTestRule
        .newClientBuilder()
        .cache(cache)
        .cookieJar(JavaNetCookieJar(cookieManager))
        .build()
  }

  @AfterEach

* Use Docker API Version instead of docker version ([#44068](https://github.com/kubernetes/kubernetes/pull/44068), [@mkumatag](https://github.com/mkumatag))
* bump(golang.org/x/oauth2): a6bd8cefa1811bd24b86f8902872e4e8225f74c4 ([#45056](https://github.com/kubernetes/kubernetes/pull/45056), [@ericchiang](https://github.com/ericchiang))

import static org.codelibs.core.misc.AssertionUtil.assertArgumentNotNull;

import java.lang.reflect.Constructor;
import java.lang.reflect.Field;
import java.lang.reflect.Method;
import java.lang.reflect.Type;
import java.lang.reflect.TypeVariable;
import java.util.Arrays;
import java.util.List;
import java.util.Map;
import java.util.Set;

import org.codelibs.core.beans.BeanDesc;

    * nonexistent.  This patch adds an anonymous function call inside
    * the loop to correctly handle acquiring the write lock with deferred
    * unlock to run at that function's completion, following the normal
    * golang lock/deferred-unlock pattern.
* Avoid creating new controller revisions for statefulsets when cache is stale ([#67039](https://github.com/kubernetes/kubernetes/pull/67039), [@mortent](https://github.com/mortent))

            result.setErrorLog(DfTypeUtil.toString(source.get("errorLog")));
            result.setErrorName(DfTypeUtil.toString(source.get("errorName")));
            result.setLastAccessTime(DfTypeUtil.toLong(source.get("lastAccessTime")));
            result.setThreadName(DfTypeUtil.toString(source.get("threadName")));
            result.setUrl(DfTypeUtil.toString(source.get("url")));
            return updateEntity(source, result);

        try {
            final RESULT result = entityType.newInstance();
            result.setCreatedBy(DfTypeUtil.toString(source.get("createdBy")));
            result.setCreatedTime(DfTypeUtil.toLong(source.get("createdTime")));
            result.setGenerator(DfTypeUtil.toString(source.get("generator")));
            result.setPath(DfTypeUtil.toString(source.get("path")));

      result.add(
        0,
        HeldCertificate
          .Builder()
          .signedBy(if (result.isNotEmpty()) result[0] else null)
          .certificateAuthority(length - i)
          .serialNumber(i.toLong())
          .build(),
      )
    }
    return result
  }

  private fun list(vararg heldCertificates: HeldCertificate): List<Certificate> {
    val result: MutableList<Certificate> = ArrayList()

        .add("Connection", "keep-alive")
        .add("Transfer-Encoding", "chunked")
        .build()
    assertThat(headers2).isNotEqualTo(headers1)
    assertThat(headers2.hashCode()).isNotEqualTo(headers1.hashCode().toLong())
  }

  @Test fun headersToString() {
    val headers =
      Headers
        .Builder()
        .add("A", "a")
        .add("B", "bb")
        .build()

    fileSystem.write(journalFileTmp) {
      writeUtf8(MAGIC).writeByte('\n'.code)
      writeUtf8(VERSION_1).writeByte('\n'.code)
      writeDecimalLong(appVersion.toLong()).writeByte('\n'.code)
      writeDecimalLong(valueCount.toLong()).writeByte('\n'.code)
      writeByte('\n'.code)

      for (entry in lruEntries.values) {
        if (entry.currentEditor != null) {
          writeUtf8(DIRTY).writeByte(' '.code)