resp, err := c.Ping(
		c.Ping.WithContext(ctx),
	)
	if err != nil {
		return false, store.ErrNotConnected
	}
	xhttp.DrainBody(resp.Body)
	return !resp.IsError(), nil
}

func (c *esClientV7) entryExists(ctx context.Context, index string, key string) (bool, error) {
	res, err := c.Exists(
		index,
		key,
		c.Exists.WithContext(ctx),
	)
	if err != nil {
		return false, err
	}

		},
		ConnectDone: func(network, addr string, err error) {
			if err == nil {
				atomic.StoreInt64(&dialEnd, time.Now().UnixNano())
			}
		},
	}

	return req.WithContext(httptrace.WithClientTrace(req.Context(), trace)), func() {
		if ds := atomic.LoadInt64(&dialStart); ds > 0 {
			if de := atomic.LoadInt64(&dialEnd); de == 0 {
				atomic.AddUint64(&globalStats.tcpDialErrs, 1)

	outReq.ProtoMajor = 1
	outReq.ProtoMinor = 1

	f.rewriter.Rewrite(outReq)

	// Disable closeNotify when method GET for http pipelining
	if outReq.Method == http.MethodGet {
		quietReq := outReq.WithContext(context.Background())
		*outReq = *quietReq
	}
}

// headerRewriter is responsible for removing hop-by-hop headers and setting forwarding headers
type headerRewriter struct{}

	}).Find(&users1)

	if result.RowsAffected != 2 {
		t.Errorf("Should found two users's name in 1, 2, but got %v", result.RowsAffected)
	}

	var maxId int64
	userTable := func(db *gorm.DB) *gorm.DB {
		return db.WithContext(context.Background()).Table("users")
	}
	if err := DB.Scopes(userTable).Select("max(id)").Scan(&maxId).Error; err != nil {
		t.Errorf("select max(id)")
	}
}

func TestComplexScopes(t *testing.T) {

func TestCancelTransaction(t *testing.T) {
	ctx := context.Background()
	ctx, cancelFunc := context.WithCancel(ctx)
	cancelFunc()

	user := *GetUser("cancel_transaction", Config{})
	DB.Create(&user)

	err := DB.WithContext(ctx).Transaction(func(tx *gorm.DB) error {
		var result User
		tx.First(&result, user.ID)
		return nil
	})

	if err == nil {
		t.Fatalf("Transaction should get error when using cancelled context")
	}
}

		tc := mcontext.TraceCtxt{
			AmzReqID:         w.Header().Get(xhttp.AmzRequestID),
			RequestRecorder:  reqRecorder,
			ResponseRecorder: respRecorder,
		}

		r = r.WithContext(context.WithValue(r.Context(), mcontext.ContextTraceKey, &tc))

		reqStartTime := time.Now().UTC()
		h.ServeHTTP(respRecorder, r)
		reqEndTime := time.Now().UTC()

		t.Fatalf("should assign PreparedStatement Manager back to database when using PrepareStmt mode")
	}

	ctx, cancel := context.WithTimeout(context.Background(), 500*time.Millisecond)
	defer cancel()
	txCtx := tx.WithContext(ctx)

	user := *GetUser("prepared_stmt", Config{})

	txCtx.Create(&user)

	var result1 User
	if err := txCtx.Find(&result1, user.ID).Error; err != nil {
		t.Fatalf("no error should happen but got %v", err)

		Method:     method,
		URL:        &u,
		Proto:      "HTTP/1.1",
		ProtoMajor: 1,
		ProtoMinor: 1,
		Header:     make(http.Header),
		Body:       rc,
		Host:       u.Host,
	}
	req = req.WithContext(ctx)
	if body != nil {
		switch v := body.(type) {
		case *bytes.Buffer:
			req.ContentLength = int64(v.Len())
			buf := v.Bytes()
			req.GetBody = func() (io.ReadCloser, error) {

	handlerName := getHandlerName(f, "adminAPIHandlers")

	var handler http.HandlerFunc = func(w http.ResponseWriter, r *http.Request) {
		// Update request context with `logger.ReqInfo`.
		r = r.WithContext(newContext(r, w, handlerName))

		defer logger.AuditLog(r.Context(), w, r, mustGetClaimsFromToken(r))

		// Check if object layer is available, if not return error early.
		if !handlerFlags.Has(noObjLayerFlag) {

HSPLkotlin/TuplesKt;-><clinit>()V
HSPLkotlin/TuplesKt;->launch$default(Lkotlinx/coroutines/CoroutineScope;Lkotlin/coroutines/CoroutineContext;ILkotlin/jvm/functions/Function2;ILjava/lang/Object;)Lkotlinx/coroutines/Job;
HSPLkotlin/TuplesKt;->withContext(Lkotlin/coroutines/CoroutineContext;Lkotlin/jvm/functions/Function2;Lkotlin/coroutines/Continuation;)Ljava/lang/Object;
HSPLkotlin/UNINITIALIZED_VALUE;-><clinit>()V
HSPLkotlin/UNINITIALIZED_VALUE;-><init>()V