log.debug("Cannot reuse, signing enforced on connection " + conn);
                        }
                        continue;
                    }

                    if ( !conn.getNegotiateResponse().canReuse(tc, forceSigning) ) {
                        if ( log.isTraceEnabled() ) {
                            log.trace("Cannot reuse, different config " + conn);
                        }

The wrapper will handle all serialization and de-seralization of the request and response,
and furthermore provides reuse of the structs used for the request and response.

Note that Responses sent for serialization are automatically reused for similar requests.
If the response contains shared data it will cause issues, since each unique response is reused.
To disable this behavior, use `(SingleHandler).WithSharedResponse()` to disable it.

Since HTTP requests frequently happen in parallel, connection pooling must be thread-safe.

These are the primary classes involved with establishing, sharing, and terminating connections:

//
// Subsequently this allows golang http RoundTripper
// to reuse the same connection for future requests.
func DrainBody(respBody io.ReadCloser) {
	// Callers should close resp.Body when done reading from it.
	// If resp.Body is not closed, the Client's underlying RoundTripper
	// (typically Transport) may not be able to reuse a persistent TCP
	// connection to the server for a subsequent "keep-alive" request.

import org.junit.jupiter.api.Disabled;
import org.junit.jupiter.api.Test;
import org.junit.jupiter.api.io.CleanupMode;
import org.junit.jupiter.api.io.TempDir;

/**
 * Resident UT.
 */
@Disabled(
        "The tests reuse properties from the JVM being launched, thus may lead to failures depending on which options are used")
public class DefaultResidentMavenInvokerTest

 * See the License for the specific language governing permissions and
 * limitations under the License.
 */
package okhttp3.internal.connection

/** Reuse a connection from the pool. */
internal class ReusePlan(
  val connection: RealConnection,
) : RoutePlanner.Plan {
  override val isReady = true

  override fun connectTcp() = error("already connected")

 * Fix: Persist proper `Content-Encoding` header to cache for GZip responses.
 * Fix: Eliminate rare race condition in SPDY streams that would prevent connection reuse.
 * Fix: Change HTTP date formats to UTC to conform to RFC2616 section 3.3.
 * Fix: Support SPDY header blocks with trailing bytes.
 * Fix: Allow `;` as separator for `Cache-Control` header.

            connectionUser.releaseConnectionNoEvents()
          }
          else -> null
        }
      }

    // If the call's connection wasn't released, reuse it. We don't call connectionAcquired() here
    // because we already acquired it.
    if (connectionUser.candidateConnection() != null) {
      check(toClose == null)
      return ReusePlan(candidate)
    }

          annotationClass.getDeclaringClass(),
          returnType.getComponentType());
    }
  }

  // This is public so that tests for Feature enums we haven't yet imagined
  // can reuse it.
  public static <E extends Enum<?> & Feature<?>> void assertGoodFeatureEnum(
      Class<E> featureEnumClass) {
    final Class<?>[] classes = featureEnumClass.getDeclaredClasses();

/** @author Jesse Wilson */
final class Platform {

  private static final char[] CHAR_BUFFER = new char[1024];

  static char[] charBufferFromThreadLocal() {
    // ThreadLocal is not available to GWT, so we always reuse the same
    // instance.  It is always safe to return the same instance because
    // javascript is single-threaded, and only used by blocks that doesn't
    // involve async callbacks.
    return CHAR_BUFFER;
  }