// for technical reasons we cannot throw here, even if delegate does cancel transfer
            listener.transferInitiated(event(session, resource, TransferEvent.EventType.INITIATED));

            Thread.sleep(500); // to make sure queue is processed, cancellation applied

            // subsequent call will cancel
            assertThrows(
                    TransferCancelledException.class,

function setupTermynal() {
    document.querySelectorAll(".use-termynal").forEach(node => {
        node.style.display = "block";
        new Termynal(node, {
            lineDelay: 500
        });
    });
    const progressLiteralStart = "---> 100%";
    const promptLiteralStart = "$ ";
    const customPromptLiteralStart = "# ";
    const termynalActivateClass = "termy";
    let termynals = [];

    function createTermynals() {

      future.addListener(listenerLatch::countDown, exec);
    }

    assertSame(Boolean.TRUE, future.get());
    // Wait for the listener latch to complete.
    listenerLatch.await(500, MILLISECONDS);

    exec.shutdown();
    exec.awaitTermination(500, MILLISECONDS);
  }

  val s =
    when {
      ns <= -999_500_000 -> "${(ns - 500_000_000) / 1_000_000_000} s "
      ns <= -999_500 -> "${(ns - 500_000) / 1_000_000} ms"
      ns <= 0 -> "${(ns - 500) / 1_000} µs"
      ns < 999_500 -> "${(ns + 500) / 1_000} µs"
      ns < 999_500_000 -> "${(ns + 500_000) / 1_000_000} ms"
      else -> "${(ns + 500_000_000) / 1_000_000_000} s "
    }
  return String.format("%6s", s)

      future.addListener(listenerLatch::countDown, exec);
    }

    assertSame(Boolean.TRUE, future.get());
    // Wait for the listener latch to complete.
    listenerLatch.await(500, MILLISECONDS);

    exec.shutdown();
    exec.awaitTermination(500, MILLISECONDS);
  }

            byte[] data = new byte[100];
            new Random().nextBytes(data);
            request.setData(data, 0, data.length);
            request.setOffset(1024L);
            request.setRemainingBytes(500);
            request.setWriteFlags(0x01);

            byte[] buffer = new byte[1024];
            int headerStart = 64; // Simulated header start

            // Execute

        // for technical reasons we cannot throw here, even if delegate does cancel transfer
        listener.transferInitiated(event(session, resource, TransferEvent.EventType.INITIATED));

        Thread.sleep(500); // to make sure queue is processed, cancellation applied

        // subsequent call will cancel
        assertThrows(
                TransferCancelledException.class,

    private static final Logger LOGGER = LoggerFactory.getLogger(SimplexTransferListener.class);
    private static final int QUEUE_SIZE = 1024;
    private static final int BATCH_MAX_SIZE = 500;
    private final TransferListener delegate;
    private final int batchMaxSize;
    private final boolean blockOnLastEvent;
    private final ArrayBlockingQueue<Exchange> eventQueue;

    /**

        SMBUtil.writeInt2(500, buffer, bufferIndex);
        SMBUtil.writeInt2(0, buffer, bufferIndex + 2);
        SMBUtil.writeInt2(TransPeekNamedPipeResponse.STATUS_LISTENING, buffer, bufferIndex + 4);

        // Act
        int result = response.readParametersWireFormat(buffer, bufferIndex, 6);

        // Assert
        assertEquals(6, result);
        assertEquals(500, response.getAvailable());

	if err != nil {
		return cfg, err
	}
	if replicationMaxWorkers <= 0 || replicationMaxWorkers > 500 {
		return cfg, config.ErrInvalidReplicationWorkersValue(nil).Msg("Number of replication workers should be between 1 and 500")
	}
	cfg.ReplicationMaxWorkers = replicationMaxWorkers