os.Exit(0)
		}

		os.Exit(1)
	}

	stopProcess := func() bool {
		shutdownHealMRFWithTimeout() // this can take time sometimes, it needs to be executed
		// before stopping s3 operations

		// send signal to various go-routines that they need to quit.
		cancelGlobalContext()

		if httpServer := newHTTPServerFn(); httpServer != nil {
			if err := httpServer.Shutdown(); err != nil && !errors.Is(err, http.ErrServerClosed) {

Then you just do the same in your tests.

E.g.:

* To pass a *path* or *query* parameter, add it to the URL itself.
* To pass a JSON body, pass a Python object (e.g. a `dict`) to the parameter `json`.
* If you need to send *Form Data* instead of JSON, use the `data` parameter instead.
* To pass *headers*, use a `dict` in the `headers` parameter.
* For *cookies*, a `dict` in the `cookies` parameter.

			val:   0.61,
			label: labels[3],
		},
		{
			val:   0.79,
			label: labels[2],
		},
	}
	ticker := time.NewTicker(1 * time.Millisecond)
	defer ticker.Stop()
	for _, obs := range observations {
		// Send observations once every 1ms, to simulate delay between
		// observations. This is to test the channel based
		// synchronization used internally.
		<-ticker.C
		ttfbHist.With(prometheus.Labels{"api": obs.label}).Observe(obs.val)

```Python
app.dependency_overrides = {}
```

/// tip

If you want to override a dependency only during some tests, you can set the override at the beginning of the test (inside the test function) and reset it at the end (at the end of the test function).

	if err != nil {
		return err
	}
	if msg.Flags&FlagCRCxxh3 != 0 {
		h := xxh3.Hash(dst)
		dst = binary.LittleEndian.AppendUint32(dst, uint32(h))
	}
	return c.send(c.ctx, dst)
}

// sendMsg will send
func (c *Connection) sendMsg(conn net.Conn, msg message, payload msgp.MarshalSizer) error {
	if payload != nil {
		if sz := payload.Msgsize(); cap(msg.Payload) < sz {
			PutByteBuffer(msg.Payload)

    /**
     * Default maximum number of receive credits
     */
    public static final int DEFAULT_RECEIVE_CREDIT_MAX = 255;

    /**
     * Default target number of send credits
     */
    public static final int DEFAULT_SEND_CREDIT_TARGET = 32;

    /**
     * Default maximum receive size (8KB)
     */
    public static final int DEFAULT_MAX_RECEIVE_SIZE = 8192;

    /**

 */
package org.apache.maven.artifact.resolver;

import org.apache.maven.artifact.Artifact;
import org.apache.maven.artifact.versioning.VersionRange;
import org.codehaus.plexus.logging.Logger;

/**
 * Send resolution warning events to the warning log.
 *
 */
@Deprecated
public class WarningResolutionListener implements ResolutionListener {
    private Logger logger;

    public WarningResolutionListener(Logger logger) {

	notificationEventsSkippedTotal    = "events_skipped_total"
)

var (
	notificationCurrentSendInProgressMD = NewCounterMD(notificationCurrentSendInProgress, "Number of concurrent async Send calls active to all targets")
	notificationEventsErrorsTotalMD     = NewCounterMD(notificationEventsErrorsTotal, "Events that were failed to be sent to the targets")

	endpointL             = "endpoint"
)

var (
	allWebhookLabels        = []string{nameL, endpointL}
	webhookFailedMessagesMD = NewCounterMD(webhookFailedMessages,
		"Number of messages that failed to send",
		allWebhookLabels...)
	webhookQueueLengthMD = NewGaugeMD(webhookQueueLength,
		"Webhook queue length",
		allWebhookLabels...)
	webhookTotalMessagesMD = NewCounterMD(webhookTotalMessages,

        throw new DfsReferral(dr);
    }

    <T extends CommonServerMessageBlockResponse> T send(final CommonServerMessageBlockRequest request, final T response)
            throws SmbException {
        return send(request, response, Collections.<RequestParam> emptySet());
    }

    <T extends CommonServerMessageBlockResponse> T send(final CommonServerMessageBlockRequest request, T response,