val request1ReceivedAt = System.currentTimeMillis()
    assertThat(server.takeRequest().headers["If-None-Match"]).isNull()

    // Hit that stored response. It's different, but Vary says it doesn't matter.
    Thread.sleep(10) // Make sure the timestamps are unique.
    val cacheHit =
      executeSynchronously(
        "/",
        "Accept-Language",
        "en-US",
        "Accept-Charset",
        "UTF-8",
      )

        long deadline = System.currentTimeMillis() + 5000;  // 5 second timeout
        
        while (!rdmaConnection.canSend() && System.currentTimeMillis() < deadline) {
            try {
                Thread.sleep(10);
            } catch (InterruptedException e) {
                Thread.currentThread().interrupt();
                throw new IOException("Interrupted waiting for send credit", e);
            }
        }

	bucketIdx := c.nextCleanupBucket
	timeToExpire := time.Until(c.buckets[bucketIdx].newestEntry)
	// wait for newest entry to expire before cleanup without holding lock
	if timeToExpire > 0 {
		c.mu.Unlock()
		time.Sleep(timeToExpire)
		c.mu.Lock()
	}
	for _, ent := range c.buckets[bucketIdx].entries {
		c.removeElement(ent)
	}
	c.nextCleanupBucket = (c.nextCleanupBucket + 1) % numBuckets
	c.mu.Unlock()
}

				return
			}

			h.config.LogOnceIf(
				context.Background(),
				fmt.Errorf("unable to send audit/log entry(s) to '%s' err '%w': %d", name, err, count),
				name,
			)

			time.Sleep(retryIntvl)
			if maxRetries == 0 {
				goto retry
			}
			retries++
			if retries <= maxRetries {
				goto retry
			}
		}

		entries = make([]any, 0)
		count = 0
		if !isDirQueue {

like what I get" is the same thing as "I get what I like"!'

  `You might just as well say,' added the Dormouse, who seemed to
be talking in his sleep, `that "I breathe when I sleep" is the
same thing as "I sleep when I breathe"!'

  `It IS the same thing with you,' said the Hatter, and here the
conversation dropped, and the party sat silent for a minute,

	user.Age = 20
	if err := DB.Create(&user).Error; err != nil {
		t.Errorf("failed to create user, got error %v", err)
	}

	var user2 User
	DB.First(&user2, user.ID)
	user2.Age = 30
	time.Sleep(time.Second)
	if err := DB.Clauses(clause.OnConflict{UpdateAll: true}).Create(&user2).Error; err != nil {
		t.Fatalf("failed to onconflict create user, got error %v", err)
	} else {
		var user3 User
		DB.First(&user3, user.ID)

                        numberOfSuggestDocs += res.getNumberOfSuggestDocs();
                        numberOfInputDocs += res.getNumberOfInputDocs();
                        queryLogs.clear();

                        Thread.sleep(requestInterval);
                    }
                }
                deferred.resolve(
                        new SuggestIndexResponse(numberOfSuggestDocs, numberOfInputDocs, errors, System.currentTimeMillis() - start));

    assertThat(server.takeRequest().exchangeIndex).isEqualTo(0)

    // Give the server time to enact the socket policy if it's one that could happen after the
    // client has received the response.
    Thread.sleep(500)
    val response2 = getResponse(newRequest("/b"))
    response1.body
      .source()
      .timeout()
      .timeout(100, TimeUnit.MILLISECONDS)

			<-ctx.Done()
			return
		}
		duration := max(time.Duration(r.Float64()*float64(time.Minute)),
			// Make sure to sleep at least a second to avoid high CPU ticks.
			time.Second)
		time.Sleep(duration)
	}
}

// Loads bucket replication resync statuses into memory.

    // Service b startup takes at least 353 millis, but starting the timer is delayed by at least
    // 150 milliseconds. so in a perfect world the timing would be 353-150=203ms, but since either
    // of our sleep calls can be arbitrarily delayed we should just assert that there is a time
    // recorded.
    assertThat(startupTimes.get(b)).isNotNull();
  }

  public void testServiceStartStop() {