void testWriteParameterWordsWireFormatLargeOffset() {
        byte[] dst = new byte[512];
        int startOffset = 100;

        // Set up transaction parameters
        transaction.setMaxSetupCount((byte) 3);
        transaction.setTotalParameterCount(500);
        transaction.setTotalDataCount(1000);
        transaction.setMaxParameterCount(2048);
        transaction.setMaxDataCountForTest(4096);

func TestLRUConcurrency(t *testing.T) {
	lc := lru.NewLRU[string, string](0, nil, 0)
	wg := sync.WaitGroup{}
	wg.Add(1000)
	for i := 0; i < 1000; i++ {
		go func(i int) {
			lc.Add(fmt.Sprintf("key-%d", i/10), fmt.Sprintf("val-%d", i/10))
			wg.Done()
		}(i)
	}
	wg.Wait()
	if lc.Len() != 100 {
		t.Fatalf("length differs from expected")
	}
}

func TestLRUInvalidateAndEvict(t *testing.T) {

        assertNull(exception.getCause());
    }

    public void test_constructor_withLongMessage() {
        // Test with a long message
        StringBuilder sb = new StringBuilder();
        for (int i = 0; i < 1000; i++) {
            sb.append("LDAP configuration error ").append(i).append(" ");
        }
        String longMessage = sb.toString();

    }

    public void test_longMessage() {
        // Test with very long message
        StringBuilder sb = new StringBuilder();
        for (int i = 0; i < 1000; i++) {
            sb.append("Long message part ").append(i).append(" ");
        }
        String longMessage = sb.toString();

        ScheduledJobException exception = new ScheduledJobException(longMessage);

    }

    public void test_longMessageHandling() {
        // Test with very long message
        StringBuilder longMessage = new StringBuilder();
        for (int i = 0; i < 1000; i++) {
            longMessage.append("Storage error ").append(i).append(" ");
        }
        String message = longMessage.toString();

        StorageException exception = new StorageException(message);

  @J2ktIncompatible
  @GwtIncompatible // blocking wait
  public void testRunIdempotency() throws Exception {
    int numThreads = 10;
    ExecutorService executor = newFixedThreadPool(numThreads);
    for (int i = 0; i < 1000; i++) {
      AtomicInteger counter = new AtomicInteger();
      TrustedListenableFutureTask<Integer> task =
          TrustedListenableFutureTask.create(
              new Callable<Integer>() {
                @Override

    return ImmutableList.of(
        Striped.readWriteLock(100),
        Striped.readWriteLock(256),
        Striped.lock(100),
        Striped.lock(256),
        Striped.custom(100, FAIR_LOCK_SUPPLER),
        Striped.custom(256, FAIR_LOCK_SUPPLER),
        Striped.semaphore(100, 1),
        Striped.semaphore(256, 1));
  }

    return ImmutableList.of(
        Striped.readWriteLock(100),
        Striped.readWriteLock(256),
        Striped.lock(100),
        Striped.lock(256),
        Striped.custom(100, FAIR_LOCK_SUPPLER),
        Striped.custom(256, FAIR_LOCK_SUPPLER),
        Striped.semaphore(100, 1),
        Striped.semaphore(256, 1));
  }

    // Backoff and timing constants (in ms)
    private static final long BASE_POLL_INTERVAL = 1000;
    private static final long MAX_POLL_INTERVAL = 30000;
    private static final long BASE_RETRY_DELAY = 1000;
    private static final long MAX_RETRY_DELAY = 30000;
    private static final int MAX_BACKOFF_SHIFT = 3; // Maximum 8 seconds (2^3 * 1000ms)

   * response is ready.
   */
  @Test
  fun dispatchBlocksWaitingForEnqueue() {
    Thread {
      try {
        Thread.sleep(1000)
      } catch (ignored: InterruptedException) {
      }
      server.enqueue(MockResponse().setBody("enqueued in the background"))
    }.start()
    val connection = server.url("/").toUrl().openConnection()