assertTrue(addresses.length > 0, "Should return at least one address");
    }

    @Test
    @DisplayName("Should handle NetBIOS name resolution with timeout")
    @Timeout(value = 2, unit = TimeUnit.SECONDS) // Force test timeout
    void testGetNbtByName() {
        // When/Then - Should throw UnknownHostException quickly due to short timeouts
        UnknownHostException exception = assertThrows(UnknownHostException.class, () -> {

          t: Throwable,
          response: Response?,
        ) {
          t.printStackTrace(System.out)
          latch.countDown()
        }
      },
    )

    check(latch.await(30, TimeUnit.SECONDS)) { "Timed out waiting for test $number to finish." }
    val endNanos = System.nanoTime()
    val tookMs = TimeUnit.NANOSECONDS.toMillis(endNanos - startNanos.get())
    println("Took ${tookMs}ms")
  }

import static com.google.common.cache.TestingRemovalListeners.queuingRemovalListener;
import static com.google.common.truth.Truth.assertThat;
import static java.util.concurrent.TimeUnit.SECONDS;
import static org.junit.Assert.assertThrows;

import com.google.common.cache.CacheLoader.InvalidCacheLoadException;
import com.google.common.cache.TestingRemovalListeners.QueuingRemovalListener;

import static com.google.common.cache.TestingRemovalListeners.queuingRemovalListener;
import static com.google.common.truth.Truth.assertThat;
import static java.util.concurrent.TimeUnit.SECONDS;
import static org.junit.Assert.assertThrows;

import com.google.common.cache.CacheLoader.InvalidCacheLoadException;
import com.google.common.cache.TestingRemovalListeners.QueuingRemovalListener;

import static com.google.common.util.concurrent.Uninterruptibles.awaitUninterruptibly;
import static java.util.concurrent.Executors.newSingleThreadExecutor;
import static java.util.concurrent.TimeUnit.SECONDS;
import static org.junit.Assert.assertThrows;

import com.google.common.util.concurrent.ClosingFuture.ClosingCallable;
import com.google.common.util.concurrent.ClosingFuture.DeferredCloser;

package com.google.common.util.concurrent;

import static com.google.common.util.concurrent.MoreExecutors.directExecutor;
import static java.util.concurrent.Executors.newCachedThreadPool;
import static java.util.concurrent.TimeUnit.SECONDS;

import com.google.common.testing.NullPointerTester;
import java.util.concurrent.CountDownLatch;
import java.util.concurrent.Executor;
import java.util.concurrent.atomic.AtomicInteger;
import junit.framework.TestCase;

  fun completeBuilder() {
    val cacheControl =
      CacheControl
        .Builder()
        .noCache()
        .noStore()
        .maxAge(1, TimeUnit.SECONDS)
        .maxStale(2, TimeUnit.SECONDS)
        .minFresh(3, TimeUnit.SECONDS)
        .onlyIfCached()
        .noTransform()
        .immutable()
        .build()
    assertThat(cacheControl.toString()).isEqualTo(

    protected final ConcurrentHashMap<String, JobProcess> runningProcessMap = new ConcurrentHashMap<>();

    /** Timeout in seconds for process destruction */
    protected int processDestroyTimeout = 10;

    /** Timeout in seconds for stream closing operations */
    protected int streamCloseTimeout = 10;

    /**
     * Default constructor for ProcessHelper.

        assertTrue(r1.getName().endsWith("/"), "Name should end with '/'");

        assertTrue(itr.hasNext(), "Should have second element ready");
        SmbResource r2 = itr.next();
        assertNotNull(r2, "Second adapted resource must not be null");
        assertTrue(r2.getName().endsWith("/"), "Name should end with '/'");

            assertEquals(second, third.next());
            assertEquals(referralData, second.next());
        }

        @Test
        @DisplayName("Should handle next() correctly")
        void testNext() {
            DfsReferralDataImpl second = new DfsReferralDataImpl();
            referralData.append(second);

            DfsReferralDataImpl next = referralData.next();
            assertSame(second, next);
        }