/**
 * A sink that executes [trigger] after [triggerByteCount] bytes are written, and then skips all
 * subsequent bytes.
 */
internal class TriggerSink(
  private val delegate: Sink,
  private val triggerByteCount: Long,
  private val trigger: () -> Unit,
) : Sink by delegate {
  private var bytesWritten = 0L

  override fun write(
    source: Buffer,
    byteCount: Long,
  ) {

    public Deferred() {
        // nothing
    }

    private RESPONSE response = null;

    private Throwable error = null;

    private final Promise promise = new Promise();

    private final Queue<Consumer<RESPONSE>> doneCallbacks = new LinkedBlockingQueue<>();

    private final Queue<Consumer<Throwable>> errorCallbacks = new LinkedBlockingQueue<>();

    private final CountDownLatch latch = new CountDownLatch(1);

    /**

      firstNode.nextSibling = null;
      this.count = 1;
    }
  }

  private transient @Nullable Node<K, V> head; // the head for all keys
  private transient @Nullable Node<K, V> tail; // the tail for all keys
  private transient Map<K, KeyList<K, V>> keyToKeyList;
  private transient int size;

  /*
   * Tracks modifications to keyToKeyList so that addition or removal of keys invalidates

public class ClRuntimeException extends RuntimeException {

    private static final long serialVersionUID = -4452607868694297329L;

    /**
     * The message code.
     */
    private final String messageCode;

    /**
     * The arguments for the message.
     */
    private final Object[] args;

    /**
     * The formatted message.
     */
    private final String message;

    /**

    private static final long serialVersionUID = -3508955801981550317L;

    /**
     * The target class.
     */
    private final Class<?> targetClass;

    /**
     * The name of the method.
     */
    private final String methodName;

    /**
     * The classes of the method arguments.
     */
    private final Class<?>[] methodArgClasses;

    /**

@Tag("Slowish")
class ThreadInterruptTest {
  @RegisterExtension
  val platform = PlatformRule()

  @RegisterExtension
  val clientTestRule = OkHttpClientTestRule()
  private lateinit var server: MockWebServer
  private lateinit var client: OkHttpClient

  @BeforeEach
  fun setUp() {
    // Sockets on some platforms can have large buffers that mean writes do not block when

  protected static final int SLOW_FUNC_VALID_INPUT_DATA = 3;
  private static final String RESULT_DATA = "SUCCESS";

  private SettableFuture<String> outputFuture;
  // Signals that the function is waiting to complete
  private CountDownLatch funcIsWaitingLatch;
  // Signals the function so it will complete
  private CountDownLatch funcCompletionLatch;

  @Override

        SubscriberRegistry.flattenHierarchy(HierarchyFixture.class));
  }

  private interface HierarchyFixtureInterface {
    // Exists only for hierarchy mapping; no members.
  }

  private interface HierarchyFixtureSubinterface extends HierarchyFixtureInterface {
    // Exists only for hierarchy mapping; no members.
  }

  private static class HierarchyFixtureParent implements HierarchyFixtureSubinterface {

  protected static final int SLOW_FUNC_VALID_INPUT_DATA = 3;
  private static final String RESULT_DATA = "SUCCESS";

  private SettableFuture<String> outputFuture;
  // Signals that the function is waiting to complete
  private CountDownLatch funcIsWaitingLatch;
  // Signals the function so it will complete
  private CountDownLatch funcCompletionLatch;

  @Override

     */
    public static final int DEFAULT_HTTP_PORT = 80;

    /**
     * Default constructor for SMB1 HTTP URL handler.
     */
    public Handler() {
    }

    private static final Map PROTOCOL_HANDLERS = new HashMap();

    private static final String HANDLER_PKGS_PROPERTY = "java.protocol.handler.pkgs";

    /**
     * Vendor-specific default packages.  If no packages are specified in