assertEquals("Test exception", e.getMessage());
        }
    }

    public void test_processThreadDump_withCustomThread() throws InterruptedException {
        CountDownLatch latch = new CountDownLatch(1);
        AtomicInteger customThreadFound = new AtomicInteger(0);

        // Create a custom thread with recognizable name
        Thread customThread = new Thread(() -> {
            try {

        final NtlmPasswordAuthenticator auth = new NtlmPasswordAuthenticator("user", "ConcurrentWipePass123!");
        final int threadCount = 20;
        final CountDownLatch startLatch = new CountDownLatch(1);
        final CountDownLatch completeLatch = new CountDownLatch(threadCount);

        // Create threads that try to wipe or access password
        for (int i = 0; i < threadCount; i++) {
            final int index = i;

        int threadCount = 10;
        int opsPerThread = 100;
        ExecutorService executor = Executors.newFixedThreadPool(threadCount);
        CountDownLatch startLatch = new CountDownLatch(1);
        CountDownLatch endLatch = new CountDownLatch(threadCount);
        AtomicInteger successCount = new AtomicInteger(0);
        List<Exception> exceptions = Collections.synchronizedList(new ArrayList<>());

        void testConcurrentReceived() throws InterruptedException {
            int threadCount = 10;
            CountDownLatch startLatch = new CountDownLatch(1);
            CountDownLatch endLatch = new CountDownLatch(threadCount);

            for (int i = 0; i < threadCount; i++) {
                new Thread(() -> {
                    try {

        setPrivateField(transport, "smb2", true);
        setPrivateField(transport, "negotiated", negotiateResponse);

        int threadCount = 10;
        CountDownLatch startLatch = new CountDownLatch(1);
        CountDownLatch doneLatch = new CountDownLatch(threadCount);
        ExecutorService executor = Executors.newFixedThreadPool(threadCount);

        // Create test data
        byte[] testData = new byte[64];

        try {
            assertEquals(0, cbWithTracking.getActiveRequests(), "Initial active requests should be 0");

            CountDownLatch startLatch = new CountDownLatch(1);
            CountDownLatch holdLatch = new CountDownLatch(1);
            CountDownLatch completeLatch = new CountDownLatch(1);

            // Start a long-running operation
            Thread longRunningThread = new Thread(() -> {
                try {

 * period or an interrupt while waiting for the expected event will result in a {@link
 * RuntimeException}.
 *
 * <p>Here's an example that tests a {@code finalize} method:
 *
 * {@snippet :
 * final CountDownLatch latch = new CountDownLatch(1);
 * Object x = new MyClass() {
 *   ...
 *   protected void finalize() { latch.countDown(); ... }
 * };
 * x = null;  // Hint to the JIT that x is stack-unreachable
 * GcFinalization.await(latch);

import java.util.concurrent.ConcurrentHashMap;
import java.util.concurrent.ConcurrentMap;
import java.util.concurrent.ConcurrentNavigableMap;
import java.util.concurrent.ConcurrentSkipListMap;
import java.util.concurrent.CountDownLatch;
import java.util.concurrent.Executor;
import java.util.concurrent.LinkedBlockingDeque;
import java.util.concurrent.ScheduledThreadPoolExecutor;
import java.util.concurrent.ThreadFactory;

        int threadCount = 20;
        int operationsPerThread = 100;
        ExecutorService executor = Executors.newFixedThreadPool(threadCount);
        CountDownLatch startLatch = new CountDownLatch(1);
        CountDownLatch endLatch = new CountDownLatch(threadCount);

        AtomicLong totalTime = new AtomicLong(0);
        AtomicInteger successCount = new AtomicInteger(0);
        List<Exception> exceptions = new ArrayList<>();

     */
    public void test_concurrentNameAccess() throws Exception {
        final int threadCount = 100;
        final int operationsPerThread = 100;
        final CountDownLatch startLatch = new CountDownLatch(1);
        final CountDownLatch endLatch = new CountDownLatch(threadCount);
        final AtomicInteger errorCount = new AtomicInteger(0);

        testTransformer.setName("concurrentName");