if (accessTimeoutTarget != null) {
                accessTimeoutTarget.stop();
                if (accessTimeoutTask != null && !accessTimeoutTask.isCanceled()) {
                    accessTimeoutTask.cancel();
                }
            }
        }
    }

    protected ResponseData getResponseData(final String uri, final boolean includeContent) {
        final ResponseData responseData = new ResponseData();

		return err
	}
	switch {
	case key.ItemCount == 1:
		var event event.Event
		event, err = target.store.Get(key)
		if err != nil {
			// The last event key in a successful batch will be sent in the channel atmost once by the replayEvents()
			// Such events will not exist and wouldve been already been sent successfully.
			if os.IsNotExist(err) {
				return nil
			}
			return err
		}
		err = target.send(event)

    val responseA = client.newCall(requestA).execute()

    assertThat(responseA.body.string()).isEqualTo("a")
    assertThat(server.takeRequest().sequenceNumber).isEqualTo(0)

    // Give the socket a chance to become stale.
    connection!!.idleAtNs -= IDLE_CONNECTION_HEALTHY_NS
    Thread.sleep(250)

    val requestB =
      Request(
        url = server.url("/"),

	healthClient.NoMetrics = true

	// Construct a new health function.
	restClient.HealthCheckFn = func() bool {
		ctx, cancel := context.WithTimeout(context.Background(), restClient.HealthCheckTimeout)
		defer cancel()
		respBody, err := healthClient.Call(ctx, peerRESTMethodHealth, nil, nil, -1)
		xhttp.DrainBody(respBody)
		return !isNetworkError(err)
	}

            return;
        }
        if (logger.isDebugEnabled()) {
            logger.debug("Closing HcHttpClient...");
        }
        if (connectionMonitorTask != null) {
            connectionMonitorTask.cancel();
        }
        if (httpClient != null) {
            try {
                httpClient.close();
            } catch (final IOException e) {
                logger.error("Failed to close httpClient.", e);

    backwards-incompatible changes in forthcoming releases.
 *  Fix: Don't crash loading the public suffix database resource in obfuscated builds.
 *  Fix: Don't silently ignore calls to `EventSource.cancel()` made from
    `EventSourceListener.onOpen()`.
 *  Fix: Enforce the max intermediates constraint when using pinned certificates with Conscrypt.

			}
			return err
		}
		target.firstPing = true
	}

	eventData, eErr := target.store.Get(key)
	if eErr != nil {
		// The last event key in a successful batch will be sent in the channel atmost once by the replayEvents()
		// Such events will not exist and would've been already been sent successfully.
		if os.IsNotExist(eErr) {
			return nil
		}
		return eErr
	}

///

## Reduzir duplicação

Reduzir a duplicação de código é uma das ideias principais no **FastAPI**.

A duplicação de código aumenta as chances de bugs, problemas de segurança, problemas de desincronização de código (quando você atualiza em um lugar, mas não em outros), etc.

E esses modelos estão compartilhando muitos dos dados e duplicando nomes e tipos de atributos.

	_, err := target.isActive()
	if err != nil {
		return err
	}

	eventData, err := target.store.Get(key)
	if err != nil {
		// The last event key in a successful batch will be sent in the channel atmost once by the replayEvents()
		// Such events will not exist and wouldve been already been sent successfully.
		if os.IsNotExist(err) {
			return nil
		}
		return err
	}

	public static final field INSTANCE Lmockwebserver3/SocketPolicy$StallSocketAtStart;
}

public abstract interface class mockwebserver3/Stream {
	public abstract fun cancel ()V
	public abstract fun getRequestBody ()Lokio/BufferedSource;
	public abstract fun getResponseBody ()Lokio/BufferedSink;
}

public abstract interface class mockwebserver3/StreamHandler {