if (i == 2) {
        // Force this request's response to be written to the cache. This way, subsequent responses
        // can be read from the cache.
        System.out.println("Force cache: true");
        clientForCall = client.newBuilder()
            .addNetworkInterceptor(REWRITE_CACHE_CONTROL_INTERCEPTOR)
            .build();
      } else {
        System.out.println("Force cache: false");
        clientForCall = client;

    int keyHash = Hashing.smearedHash(key);
    int entryForKey = findEntryByKey(key, keyHash);
    if (entryForKey != ABSENT) {
      V oldValue = values[entryForKey];
      if (Objects.equals(oldValue, value)) {
        return value;
      } else {
        replaceValueInEntry(entryForKey, value, force);
        return oldValue;
      }
    }

      }
    assertThat(requestsMade.size).isEqualTo(0)
    mockWebServer.dispatcher = dispatcher
    val url = mockWebServer.url("/").toUrl()
    val conn = url.openConnection() as HttpURLConnection
    conn.responseCode // Force the connection to hit the "server".
    // Make sure our dispatcher got the request.
    assertThat(requestsMade.size).isEqualTo(1)
  }

  @Test
  fun outOfOrderResponses() {
    val firstResponseCode = AtomicInteger()

   *       correctly, including surrogate character pairs. If the input is badly formed the escaper
   *       should throw {@link IllegalArgumentException}.
   *   <li>{@link CharEscaper} handles Java characters independently and does not verify the input
   *       for well formed characters. A {@code CharEscaper} should not be used in situations where

        }

        try {
            dataIndexHelper.crawl("test-session-force-stop");
            assertTrue("Should exit quickly when force stopped", true);
        } catch (Exception e) {
            assertTrue("Force stop should handle exceptions quickly", true);
        }
    }

    public void test_crawl_with_short_intervals() {
        try {

if [ $? -ne 0 ]; then
	echo "expected 'bucket2' delete and 'newbucket2' creation to have replicated, exiting..."
	exit_1
fi

# force a resync after removing all site replication
./mc admin replicate rm --all --force minio1
./mc rb minio2 --force --dangerous
./mc admin replicate add minio1 minio2
./mc admin replicate resync start minio1 minio2
sleep 30

	"github.com/minio/pkg/v3/sync/errgroup"
	"github.com/puzpuzpuz/xsync/v3"
)

const (
	peerS3Bucket            = "bucket"
	peerS3BucketDeleted     = "bucket-deleted"
	peerS3BucketForceCreate = "force-create"
	peerS3BucketForceDelete = "force-delete"
)

func healBucketLocal(ctx context.Context, bucket string, opts madmin.HealOpts) (res madmin.HealResultItem, err error) {
	globalLocalDrivesMu.RLock()

	if objAPI == nil {
		return
	}

	vars := mux.Vars(r)
	tier := vars["tier"]
	force := r.Form.Get("force") == "true"

	if err := globalTierConfigMgr.Reload(ctx, objAPI); err != nil {
		writeErrorResponseJSON(ctx, w, toAdminAPIErr(ctx, err), r.URL)
		return
	}

	if err := globalTierConfigMgr.Remove(ctx, tier, force); err != nil {
		writeErrorResponseJSON(ctx, w, toAdminAPIErr(ctx, err), r.URL)
		return
	}

    assertEquals(10, IntMath.saturatedAbs(10));
    assertEquals(10, IntMath.saturatedAbs(-10));
  }

  private static int force32(int value) {
    // GWT doesn't consistently overflow values to make them 32-bit, so we need to force it.
    return value & 0xffffffff;
  }

    void testIsSigningEnforcedReturnsTrue() {
        // Given
        when(negotiationRequest.isSigningEnforced()).thenReturn(true);

        // When
        boolean result = negotiationRequest.isSigningEnforced();

        // Then
        assertTrue(result, "isSigningEnforced should return true when signing is enforced");