import com.google.errorprone.annotations.DoNotMock;
import java.util.Map;
import org.jspecify.annotations.NonNull;
import org.jspecify.annotations.Nullable;

/**
 * A map, each entry of which maps a Java <a href="http://tinyurl.com/2cmwkz">raw type</a> to an
 * instance of that type. In addition to implementing {@code Map}, the additional type-safe

 * When describing the features of the collection produced by a given generator (i.e. in a call to
 * {@link
 * com.google.common.collect.testing.FeatureSpecificTestSuiteBuilder#withFeatures(Feature...)}),
 * this annotation specifies each of the different sizes for which a test suite should be built. (In
 * a typical case, the features should include {@link CollectionSize#ANY}.) These semantics are thus

    }

    private byte[] createDfsReferralBufferWithMultipleReferrals(int numReferrals) {
        // Each referral structure needs 20 bytes, plus string data
        int referralSize = 20;
        int referralsDataSize = numReferrals * referralSize;

        // Add space for string data for each referral
        String testPath = "\\server\\share";

      // Start with a suitably shaped collection of entries
      Collection<Entry<K, V>> originalEntries = mapGenerator.getSampleElements(elements.length);

      // Create a copy of that, with the desired value for each value
      Collection<Entry<K, V>> entries = new ArrayList<>(elements.length);
      int i = 0;
      for (Entry<K, V> entry : originalEntries) {
        entries.add(mapEntry(entry.getKey(), valuesArray[i++]));
      }

            }
            return uaType;
        }).orElse(UserAgentType.OTHER);
    }

    /**
     * Enumeration of supported browser types for user agent detection.
     * Each type represents a major browser family that can be detected
     * from the User-Agent header string.
     */
    public enum UserAgentType {
        /** Internet Explorer and Trident-based browsers */
        IE,

  private final Iterator<? extends ByteSource> it;
  private @Nullable InputStream in;

  /**
   * Creates a new instance.
   *
   * @param it an iterator of I/O suppliers that will provide each substream
   */
  public MultiInputStream(Iterator<? extends ByteSource> it) throws IOException {
    this.it = checkNotNull(it);
    advance();
  }

  @Override
  public void close() throws IOException {

    if (length < 0) {
      // compressed name pointer, first two bits are 1
      // drop second byte of compression offset
      source.skip(1)
    } else {
      while (length > 0) {
        // skip each part of the domain name
        source.skip(length.toLong())
        length = source.readByte().toInt()
      }
    }
  }

import com.google.j2objc.annotations.RetainedLocalRef;
import java.util.Collections;
import java.util.List;
import org.jspecify.annotations.Nullable;

/** Aggregate future that collects (stores) results of each future. */
@GwtCompatible
abstract class CollectionFuture<V extends @Nullable Object, C extends @Nullable Object>
    extends AggregateFuture<V, C> {
  /*

      implements RemovalListener<K, V> {

    @Override
    public void onRemoval(RemovalNotification<K, V> notification) {
      add(notification);
    }
  }

  /**
   * {@link RemovalListener} that counts each {@link RemovalNotification} it receives, and provides
   * access to the most-recently received one.
   */
  static class CountingRemovalListener<K, V> implements RemovalListener<K, V> {

   */
  @ParametricNullness
  E peek();

  /**
   * {@inheritDoc}
   *
   * <p>The objects returned by consecutive calls to {@link #peek()} then {@link #next()} are
   * guaranteed to be equal to each other.
   */
  @CanIgnoreReturnValue
  @Override
  @ParametricNullness
  E next();

  /**
   * {@inheritDoc}
   *