import org.junit.Test;

/**
 * @author koichik
 *
 */
public class SingleValueIteratorTest {

    /**
     *
     */
    @Test
    public void test() {
        final SingleValueIterator<String> it = new SingleValueIterator<String>("Foo");
        assertThat(it.hasNext(), is(true));
        assertThat(it.next(), is("Foo"));
        assertThat(it.hasNext(), is(not(true)));
    }

     *
     * @param request The original HTTP servlet request
     * @param servletPath The custom servlet path for this web API request
     */
    public WebApiRequest(final HttpServletRequest request, final String servletPath) {
        super(request);
        this.servletPath = servletPath;
    }

    /**
     * Gets the servlet path for this request.

/**
 * Subtype UNIX socket for a higher-fidelity impersonation of TCP sockets. This is named "tunneling"
 * because it assumes the ultimate destination has a hostname and port.
 */
final class TunnelingUnixSocket extends UnixSocket {
  private final File path;
  private InetSocketAddress inetSocketAddress;

  TunnelingUnixSocket(File path, UnixSocketChannel channel) {
    super(channel);
    this.path = path;
  }

/**
 * Benchmark for HashMultiset.add for an already-present element.
 *
 * @author Louis Wasserman
 */
@NullUnmarked
public class HashMultisetAddPresentBenchmark {
  private static final int ARRAY_MASK = 0x0ffff;
  private static final int ARRAY_SIZE = 0x10000;
  List<Multiset<Integer>> multisets = new ArrayList<>(0x10000);
  int[] queries = new int[ARRAY_SIZE];

  @BeforeExperiment
  void setUp() {

   *
   * @throws UnsupportedOperationException always
   * @deprecated Unsupported operation.
   */
  @Deprecated
  @Override
  @DoNotCall("Always throws UnsupportedOperationException")
  public final void add(@ParametricNullness E e) {
    throw new UnsupportedOperationException();
  }

  /**
   * Guaranteed to throw an exception and leave the underlying data unmodified.
   *

     */
    @Rule
    public ExpectedException exception = ExpectedException.none();

    /**
     * @throws Exception
     */
    @Test
    public void testGet() throws Exception {
        final BeanMap map = new BeanMap();
        map.put("aaa", 1);
        map.put("bbb", 2);
        assertThat(map.get("aaa"), is((Object) 1));
    }

    /**
     * @throws Exception
     */
    @Test

    /** The username extracted from SPNEGO authentication. */
    private final String username;

    /**
     * Constructs a new SpnegoCredential with the specified username.
     *
     * @param username The username obtained from SPNEGO authentication
     */
    public SpnegoCredential(final String username) {
        this.username = username;
    }

    /**

      extends ForwardingListenableFuture<V> {
    private final ListenableFuture<V> delegate;

    protected SimpleForwardingListenableFuture(ListenableFuture<V> delegate) {
      this.delegate = Preconditions.checkNotNull(delegate);
    }

    @Override
    protected final ListenableFuture<V> delegate() {
      return delegate;
    }
  }

    private static final ConcurrentMap<Class<?>, BeanDesc> beanDescCache = newConcurrentHashMap(1024);

    static {
        initialize();
    }

    /**
     * Returns a {@link BeanDesc}.
     *
     * @param clazz
     *            the Bean class. Must not be {@literal null}
     * @return {@link BeanDesc}
     */
    public static BeanDesc getBeanDesc(final Class<?> clazz) {

    /**
     * Directory Read and Handle caching (RH) - recommended for directory operations
     */
    public static final int DIRECTORY_READ_HANDLE = Smb2LeaseState.SMB2_LEASE_READ_CACHING | Smb2LeaseState.SMB2_LEASE_HANDLE_CACHING;

    /**
     * Directory Full caching (RWH) - all three lease types
     */
    public static final int DIRECTORY_FULL = Smb2LeaseState.SMB2_LEASE_FULL;

    /**
     * Check if directory can cache enumeration results