assertEquals(Integer.MAX_VALUE, ms.tailMultiset("b", CLOSED).size());
    assertEquals(Integer.MAX_VALUE, ms.tailMultiset("a", CLOSED).size());
  }

  @J2ktIncompatible
  @GwtIncompatible // reflection
  @AndroidIncompatible // Reflection bug, or actual binary compatibility problem?
  public void testElementSetBridgeMethods() {
    for (Method m : TreeMultiset.class.getMethods()) {

        Class<?> optionalClass = Class.forName("java.util.Optional");
        /*
         * We don't *need* to use reflection to access Optional: It's available on all JDKs we
         * support, and Android code won't get this far, anyway, because ProcessHandle is
         * unavailable. But given how much other reflection we're using, we might as well use it
         * here, too, so that we don't need to also suppress an AndroidApiChecker error.

   * can suppress it with {@code FeatureSpecificTestSuiteBuilder.suppressing()} until <a
   * href="https://bugs.openjdk.org/browse/JDK-5045147">JDK-5045147</a> is fixed.
   */
  @J2ktIncompatible
  @GwtIncompatible // reflection
  public static Method getCreateWithNullUnsupportedMethod() {
    return getMethod(CollectionCreationTester.class, "testCreateWithNull_unsupported");
  }

        assertEquals(800, cmd.maxDataCount, "maxDataCount should be 800");
        assertEquals(0, cmd.maxSetupCount, "maxSetupCount should be 0");
        // ensure information level is stored using reflection
        Field informationLevelField = Trans2QueryFSInformation.class.getDeclaredField("informationLevel");
        informationLevelField.setAccessible(true);

    public <T> Iterable<? super CharSequence> wildCardsDoNotMatchByLowerBound(
        List<? super String> list) {
      return notSubtype(list);
    }

    // Can't test getSupertype() or getSubtype() because JDK reflection doesn't consider
    // Foo<?> and Foo<? extends Bar> equal for class Foo<T extends Bar>
    @TestSubtype(suppressGetSupertype = true, suppressGetSubtype = true)

        // Assert
        assertSame(mocked, ex.getCause(), "Mocked cause should be preserved");
        verifyNoInteractions(mocked);
    }

    // Reflection-based check: ensure serialVersionUID remains the declared constant
    @Test
    @DisplayName("serialVersionUID matches declared constant")
    void serialVersionUID_hasExpectedValue() throws Exception {
        // Arrange

    public static <E extends Enum<E>> EnumMultiset<E> create(Iterable<E> elements) {
      return EnumMultiset.create(elements);
    }
  }

  @J2ktIncompatible
  @GwtIncompatible // reflection
  public void testEquals() throws Exception {
    new ClassSanityTester()
        .setDistinctValues(Class.class, Color.class, Gender.class)
        .setDistinctValues(Enum.class, Color.BLUE, Color.RED)

 */

package com.google.common.collect;

import static com.google.common.collect.Iterables.getOnlyElement;
import static com.google.common.collect.Iterables.unmodifiableIterable;
import static com.google.common.reflect.Reflection.newProxy;
import static java.util.Arrays.asList;

import com.google.common.annotations.GwtIncompatible;
import java.lang.reflect.InvocationHandler;
import java.lang.reflect.InvocationTargetException;

/**
 * Unit tests exercising {@link SmbComSessionSetupAndX}.  The class under test
 * contains several protected helper methods and a complex constructor
 * that branches on credential type.  These tests use reflection to call
 * protected methods and Mockito to stub collaborators.
 */
@ExtendWith(MockitoExtension.class)
@MockitoSettings(strictness = Strictness.LENIENT)
public class SmbComSessionSetupAndXTest {

    @Mock

        } catch (Exception e) {
            fail("Should not throw exception with empty map: " + e.getMessage());
        }
    }

    // Test getValueFromMap private method via reflection
    public void test_getValueFromMap() throws Exception {
        Method method = Crawler.class.getDeclaredMethod("getValueFromMap", Map.class, String.class, String.class);
        method.setAccessible(true);