}

  public void testMin_noArgs() {
    assertThrows(IllegalArgumentException.class, () -> min());
  }

  public void testMin() {
    assertThat(min(LEAST)).isEqualTo(LEAST);
    assertThat(min(GREATEST)).isEqualTo(GREATEST);
    assertThat(min((char) 8, (char) 6, (char) 7, (char) 5, (char) 3, (char) 0, (char) 9))
        .isEqualTo((char) 0);
  }

  public void testConstrainToRange() {

  }

  public void testIntersection() {
    RangeSet<Integer> expected =
        ImmutableRangeSet.<Integer>builder()
            .add(Range.closed(2, 3))
            .add(Range.open(6, 7))
            .add(Range.singleton(8))
            .build();

    assertThat(RANGE_SET_ONE.intersection(RANGE_SET_TWO)).isEqualTo(expected);
  }

  public void testDifference() {

    return ImmutableSet.copyOf(elements);
  }

  public void testCreation_allDuplicates() {
    ImmutableSet<String> set = ImmutableSet.copyOf(Lists.newArrayList("a", "a"));
    assertTrue(set instanceof SingletonImmutableSet);
    assertEquals(Lists.newArrayList("a"), new ArrayList<>(set));
  }

  public void testCreation_oneDuplicate() {
    // now we'll get the varargs overload

import org.mockito.Mock;
import org.mockito.MockitoAnnotations;

class SmbTreeTest {

    @Mock
    private SmbSession session;

    @Mock
    private SmbTransport transport;

    @BeforeEach
    void setUp() {
        MockitoAnnotations.openMocks(this);
        // Setup transport fields that are accessed directly
        transport.tconHostName = "testHost";

 */
public class RdmaProviderFactoryTest {

    @Test
    public void testCreateProviderAuto() {
        RdmaProvider provider = RdmaProviderFactory.createProvider("auto");
        assertNotNull(provider, "Auto provider selection should return a provider");
        assertTrue(provider.isAvailable(), "Returned provider should be available");
    }

    @Test
    public void testCreateProviderTcp() {

 *
 * @author Eric Chang
 */
public class TestingExecutorsTest extends TestCase {
  private volatile boolean taskDone;

  public void testNoOpScheduledExecutor() throws InterruptedException {
    taskDone = false;
    Runnable task =
        new Runnable() {
          @Override
          public void run() {
            taskDone = true;
          }
        };
    ScheduledFuture<?> future =

 *
 * @author Eric Chang
 */
public class TestingExecutorsTest extends TestCase {
  private volatile boolean taskDone;

  public void testNoOpScheduledExecutor() throws InterruptedException {
    taskDone = false;
    Runnable task =
        new Runnable() {
          @Override
          public void run() {
            taskDone = true;
          }
        };
    ScheduledFuture<?> future =

  @CollectionSize.Require(absent = ZERO)
  public void testContains_yes() {
    assertTrue("containsValue(present) should return true", getMap().containsValue(v0()));
  }

  public void testContains_no() {
    assertFalse("containsValue(notPresent) should return false", getMap().containsValue(v3()));
  }

  @MapFeature.Require(ALLOWS_NULL_VALUE_QUERIES)
  public void testContains_nullNotContainedButAllowed() {

  @CollectionSize.Require(absent = ZERO)
  public void testContains_yes() {
    assertTrue("contains(present) should return true", collection.contains(e0()));
  }

  public void testContains_no() {
    assertFalse("contains(notPresent) should return false", collection.contains(e3()));
  }

  @CollectionFeature.Require(ALLOWS_NULL_QUERIES)
  public void testContains_nullNotContainedButQueriesSupported() {

    private SmbComSetInformationResponse response;

    @BeforeEach
    void setUp() {
        // Setup mock configuration to avoid NPE
        when(mockConfig.getPid()).thenReturn(12345);

        response = new SmbComSetInformationResponse(mockConfig);
    }

    @Test
    @DisplayName("Constructor accepts valid config")
    void constructorValid() {