w.write(payload, payload.length, out);

            // Give the writer thread time to process and set exception
            w.wait(100);
        }

        // Wait a bit more to ensure exception is captured
        Thread.sleep(100);

        // Act + Assert: checkException should throw the SmbException captured by the thread

    }

    /**
     * Returns the class loader.
     * <p>
     * The class loader is searched in the following order:
     * </p>
     * <ol>
     * <li>If the context class loader is set for the calling thread, that context class loader</li>
     * <li>If the class loader that loaded the target class can be obtained, that class loader</li>
     * <li>If the class loader that loaded this class can be obtained, that class loader</li>

    LockingThread thread = new LockingThread(lockA);
    thread.start();

    thread.waitUntilHoldingLock();
    assertFalse(lockA.tryLock());

    thread.releaseLockAndFinish();
    assertTrue(lockA.tryLock());
  }

  public void testReentrantWriteLock_tryLock() throws Exception {
    LockingThread thread = new LockingThread(writeLockA);
    thread.start();

/**
 * A {@link TransferListener} implementation that wraps another delegate {@link TransferListener} but makes it run
 * on single thread, keeping the listener logic simple. This listener also blocks on last transfer event to allow
 * output to perform possible cleanup. It spawns a daemon thread to consume queued events that may fall in even
 * concurrently.
 *
 * @since 4.0.0
 */

        }

        ClassLoader oldClassLoader = Thread.currentThread().getContextClassLoader();
        try {
            Thread.currentThread().setContextClassLoader(pluginDescriptor.getClassRealm());

            return container.lookup(role, roleHint);
        } finally {
            Thread.currentThread().setContextClassLoader(oldClassLoader);
        }
    }

    @Override

        // 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,

 * <p>
 * <strong>Thread-Safety:</strong> This class is <strong>NOT thread-safe</strong>.
 * It extends {@link LinkedHashMap} without synchronization. If multiple threads access
 * an instance concurrently, and at least one thread modifies the map structurally,
 * it must be synchronized externally.
 * </p>
 * <p>
 * For thread-safe usage, wrap with {@link java.util.Collections#synchronizedMap(Map)}:

    CountDownLatch doneSignal = new CountDownLatch(1);

    Thread thread =
        new Thread() {
          @Override
          public void run() {
            try {
              cacheRef.get().getUnchecked(3);
            } finally {
              doneSignal.countDown();
            }
          }
        };
    thread.setUncaughtExceptionHandler(
        new UncaughtExceptionHandler() {

        // Simulate concurrent failures
        Thread[] threads = new Thread[5];
        for (int i = 0; i < threads.length; i++) {
            threads[i] = new Thread(() -> failover.handleFailure(failedChannel, error));
            threads[i].start();
        }

        // Wait for all threads to complete
        for (Thread thread : threads) {
            thread.join(1000);
        }

    }

    @Test
    void testConcurrentAccess() throws InterruptedException {
        // Test thread safety
        Thread[] threads = new Thread[10];
        for (int i = 0; i < threads.length; i++) {
            threads[i] = new Thread(() -> {
                channelManager.getChannels();
                channelManager.getHealthyChannels();