}
			}
		}
	}
}

func TestNewWithDelegate(t *testing.T) {
	_, ctx := ktesting.NewTestContext(t)
	ctx, cancel := context.WithCancelCause(ctx)
	defer cancel(errors.New("test is done"))
	delegateConfig := NewConfig(codecs)
	delegateConfig.ExternalAddress = "192.168.10.4:443"
	delegateConfig.PublicAddress = netutils.ParseIPSloppy("192.168.10.4")

	defer c.mutex.Unlock()

	if active := c.activePlugins[driverName]; active != nil {
		active.cancel(errors.New("plugin has re-registered"))
	}
	active := &activePlugin{}
	cancelCtx, cancel := context.WithCancelCause(c.ctx)
	active.cancel = cancel
	c.activePlugins[driverName] = active
	c.queue.Add(driverName)

	c.wg.Add(1)
	go func() {
		defer c.wg.Done()

}

// Response is a response from the server.
type Response struct {
	Msg []byte
	Err error
}

func newMuxClient(ctx context.Context, muxID uint64, parent *Connection) *muxClient {
	ctx, cancelFn := context.WithCancelCause(ctx)
	return &muxClient{
		MuxID:              muxID,
		ctx:                ctx,
		cancelFn:           cancelFn,
		parent:             parent,
		LastPong:           time.Now().UnixNano(),

	// Canceling the parent context does not immediately cancel the HTTP server.
	// We only inherit context values here and deal with cancellation ourselves.
	stopHTTPServerCtx, stopHTTPServer := context.WithCancelCause(context.WithoutCancel(ctx))
	go func() {
		defer stopHTTPServer(errors.New("time to stop HTTP server"))

		timeToStopHttpServerCh := notAcceptingNewRequestCh.Signaled()
		if s.ShutdownSendRetryAfter {

// handleMessages will handle incoming messages on conn.
// caller *must* hold reconnectMu.
func (c *Connection) handleMessages(ctx context.Context, conn net.Conn) {
	c.updateState(StateConnected)
	ctx, cancel := context.WithCancelCause(ctx)
	defer cancel(ErrDisconnected)

	// This will ensure that is something asks to disconnect and we are blocked on reads/writes
	// the connection will be closed and readers/writers will unblock.

	if err := checkListObjsArgs(ctx, bucket, prefix, ""); err != nil {
		xioutil.SafeClose(results)
		return err
	}
	parentCtx := ctx
	ctx, cancelCause := context.WithCancelCause(ctx)
	var entries []chan metaCacheEntry

	for poolIdx, erasureSet := range z.serverPools {
		for setIdx, set := range erasureSet.sets {
			set := set
			listOut := make(chan metaCacheEntry, 1)

	//     after reading the request body.
	//   - For an HTTP/2 request, RoundTrip cancels this context after the HTTP/2
	//     RoundTripper returns.
	ctx, cancel := context.WithCancelCause(req.Context())

	// Convert Request.Cancel into context cancelation.
	if origReq.Cancel != nil {
		go awaitLegacyCancel(ctx, cancel, origReq)
	}

		{"CancelFunc", Type, 7},
		{"Canceled", Var, 7},
		{"Cause", Func, 20},
		{"Context", Type, 7},
		{"DeadlineExceeded", Var, 7},
		{"TODO", Func, 7},
		{"WithCancel", Func, 7},
		{"WithCancelCause", Func, 20},
		{"WithDeadline", Func, 7},
		{"WithDeadlineCause", Func, 21},
		{"WithTimeout", Func, 7},
		{"WithTimeoutCause", Func, 21},
		{"WithValue", Func, 7},
		{"WithoutCancel", Func, 21},
	},

pkg bytes, func CutPrefix([]uint8, []uint8) ([]uint8, bool) #42537
pkg bytes, func CutSuffix([]uint8, []uint8) ([]uint8, bool) #42537
pkg context, func Cause(Context) error #51365
pkg context, func WithCancelCause(Context) (Context, CancelCauseFunc) #51365
pkg context, type CancelCauseFunc func(error) #51365
pkg crypto/ecdh, func P256() Curve #52221
pkg crypto/ecdh, func P384() Curve #52221
pkg crypto/ecdh, func P521() Curve #52221