*
   * Because the encoding of interleaved data is not well-defined for HTTP/1, duplex request
   * bodies may only be used with HTTP/2. Calls to HTTP/1 servers will fail before the HTTP request
   * is transmitted. If you cannot ensure that your client and server both support HTTP/2, do not
   * use this feature.
   *
   * ### Duplex APIs
   *
   * With regular request bodies it is not legal to write bytes to the sink passed to

    this.replacementsLength = replacements.length;
    if (safeMax < safeMin) {
      // If the safe range is empty, set the range limits to opposite extremes
      // to ensure the first test of either value will fail.
      safeMax = -1;
      safeMin = Integer.MAX_VALUE;
    }
    this.safeMin = safeMin;
    this.safeMax = safeMax;

   *
   * To avoid leaking resources callers should close the [Response] which in turn will close the
   * underlying [ResponseBody].
   *
   * ```java
   * // ensure the response (and underlying response body) is closed
   * try (Response response = client.newCall(request).execute()) {
   *   ...
   * }
   * ```
   *

import java.util.ArrayList;
import java.util.List;
import java.util.concurrent.atomic.AtomicInteger;
import org.jspecify.annotations.NullMarked;
import org.jspecify.annotations.Nullable;

/**
 * Tester to ensure forwarding wrapper works by delegating calls to the corresponding method with
 * the same parameters forwarded and return value forwarded back or exception propagated as is.
 *
 * <p>For example:
 *
 * {@snippet :

import java.util.Set;

/**
 * A wrapper implementation of Map<String, Object> that provides special handling
 * for document data. This class wraps an existing map and provides custom behavior
 * for the entrySet method to ensure language fields appear first in iteration order.
 * Used throughout the Fess search system for document data manipulation.
 *
 */
public class DocMap implements Map<String, Object> {

  public void runTest() throws Exception {
    /*
     * Note that we do not run this test under Android at the moment. For Android testing, see
     * AbstractFutureDefaultAtomicHelperTest.
     */

    // First, ensure that our classloaders are initializing the correct helper versions:

    if (isJava8()) {
      checkHelperVersion(getClass().getClassLoader(), "UnsafeAtomicHelper");
    } else {

      for (int i = off; i < off + len; i++) {
        out.write(b[i]);
      }
    } else {
      out.write(b, off, len);
    }
    out.flush(); // for coverage
  }

  // TODO(chrisn): only works if we ensure we have crossed file threshold

  public void testWriteErrorAfterClose() throws Exception {
    byte[] data = newPreFilledByteArray(100);
    FileBackedOutputStream out = new FileBackedOutputStream(50);

                throw new IOException("Failed to create new transport");
            }

            // Reconnect
            channel.setState(ChannelState.CONNECTING);
            // Connection would be ensured through proper transport interface

            // Re-establish channel binding
            manager.performChannelBinding(channel);

            // Update channel with new transport

            auth3.close();
            auth4.close();
        } finally {
            auth1.close();
            auth2.close();
        }
    }

    /**
     * Test concurrent password comparisons to ensure thread safety and consistent timing.
     */
    @Test
    public void testConcurrentTimingConsistency() throws Exception {
        final char[] password = "concurrenttestpassword".toCharArray();

import java.util.ArrayList;
import java.util.List;
import java.util.concurrent.atomic.AtomicInteger;
import org.jspecify.annotations.NullMarked;
import org.jspecify.annotations.Nullable;

/**
 * Tester to ensure forwarding wrapper works by delegating calls to the corresponding method with
 * the same parameters forwarded and return value forwarded back or exception propagated as is.
 *
 * <p>For example:
 *
 * {@snippet :