}

  /** Tests a single interaction against a method. */
  private static final class InteractionTester<T> extends AbstractInvocationHandler {

    private final Class<T> interfaceType;
    private final Method method;
    private final @Nullable Object[] passedArgs;
    private final @Nullable Object returnValue;
    private final AtomicInteger called = new AtomicInteger();

 *
 * @author Nicholaus Shupe
 */
@NullUnmarked
class CollectionBenchmarkSampleData {
  private final boolean isUserTypeFast;
  private final SpecialRandom random;
  private final double hitRate;
  private final int size;

  private final Set<Element> valuesInSet;
  private final Element[] queries;

  CollectionBenchmarkSampleData(int size) {
    this(true, new SpecialRandom(), 1.0, size);
  }

    private <T extends B> Ordering<T> ordering() {
      return Ordering.from((Comparator<T>) comparator);
    }
  }

  private final Heap minHeap;
  private final Heap maxHeap;
  @VisibleForTesting final int maximumSize;
  private @Nullable Object[] queue;
  private int size;
  private int modCount;

  private MinMaxPriorityQueue(Builder<? super E> builder, int queueSize) {

@NullUnmarked
public class UnsignedLongsBenchmark {
  private static final int ARRAY_SIZE = 0x10000;
  private static final int ARRAY_MASK = 0x0ffff;
  private static final Random randomSource = new Random(314159265358979L);
  private static final long[] longs = new long[ARRAY_SIZE];
  private static final long[] divisors = new long[ARRAY_SIZE];
  private static final String[] decimalStrings = new String[ARRAY_SIZE];

        cache.put(session, new Key(groupId, artifactId, version, tag), data);
    }

    static class Key {

        private final String groupId;

        private final String artifactId;

        private final String version;

        private final String tag;

        private final int hash;

        Key(String groupId, String artifactId, String version, String tag) {
            this.groupId = groupId;

public class DirectoryChangeNotifier {

    private static final Logger log = LoggerFactory.getLogger(DirectoryChangeNotifier.class);

    // Backoff and timing constants (in ms)
    private static final long BASE_POLL_INTERVAL = 1000;
    private static final long MAX_POLL_INTERVAL = 30000;
    private static final long BASE_RETRY_DELAY = 1000;
    private static final long MAX_RETRY_DELAY = 30000;

  private final ImmutableMap<R, Integer> rowKeyToIndex;
  private final ImmutableMap<C, Integer> columnKeyToIndex;
  private final ImmutableMap<R, ImmutableMap<C, V>> rowMap;
  private final ImmutableMap<C, ImmutableMap<R, V>> columnMap;

  @SuppressWarnings("Immutable") // We don't modify this after construction.
  private final int[] rowCounts;

class RealRoutePlanner internal constructor(
  private val taskRunner: TaskRunner,
  private val connectionPool: RealConnectionPool,
  private val readTimeoutMillis: Int,
  private val writeTimeoutMillis: Int,
  private val socketConnectTimeoutMillis: Int,
  private val socketReadTimeoutMillis: Int,
  private val pingIntervalMillis: Int,
  private val retryOnConnectionFailure: Boolean,
  private val fastFallback: Boolean,

    }

    @Override
    public byte[] getExpected(byte[] bytes) {
      return checkNotNull(bytes);
    }
  }

  private static class FileByteSinkFactory extends FileFactory implements ByteSinkFactory {

    private final byte[] initialBytes;

    private FileByteSinkFactory(byte @Nullable [] initialBytes) {
      this.initialBytes = initialBytes;
    }

    @Override

     */
    private final byte[] fileId;

    /**
     * The type of handle (DURABLE_V1, DURABLE_V2, or PERSISTENT)
     */
    private final HandleType type;

    /**
     * The timeout in milliseconds for durable handles (not applicable for persistent handles)
     */
    private final long timeout;

    /**
     * The timestamp when this handle was created
     */
    private final long createTime;