// should never reach here!
      throw new UnsupportedOperationException();
    }

    @Override
    public Entry<K, V> belowSamplesGreater() {
      // should never reach here!
      throw new UnsupportedOperationException();
    }

    @Override
    public Entry<K, V> aboveSamplesLesser() {
      // should never reach here!
      throw new UnsupportedOperationException();
    }

        LockFreeBitArray lockFreeBitArray = (LockFreeBitArray) o;
        // TODO(lowasser): avoid allocation here
        return Arrays.equals(toPlainArray(data), toPlainArray(lockFreeBitArray.data));
      }
      return false;
    }

    @Override
    public int hashCode() {
      // TODO(lowasser): avoid allocation here
      return Arrays.hashCode(toPlainArray(data));
    }
  }

      // should never reach here!
      throw new UnsupportedOperationException();
    }

    @Override
    public Entry<K, V> belowSamplesGreater() {
      // should never reach here!
      throw new UnsupportedOperationException();
    }

    @Override
    public Entry<K, V> aboveSamplesLesser() {
      // should never reach here!
      throw new UnsupportedOperationException();
    }

   *     ranges 0..9, a..z and A..Z are always safe and should not be specified here)
   * @param plusForSpace true if ASCII space should be escaped to {@code +} rather than {@code %20}
   * @throws IllegalArgumentException if any of the parameters were invalid
   */
  public PercentEscaper(String safeChars, boolean plusForSpace) {

   *     ranges 0..9, a..z and A..Z are always safe and should not be specified here)
   * @param plusForSpace true if ASCII space should be escaped to {@code +} rather than {@code %20}
   * @throws IllegalArgumentException if any of the parameters were invalid
   */
  public PercentEscaper(String safeChars, boolean plusForSpace) {

   */
  @CheckForNull @VisibleForTesting transient long[] links;

  /** Pointer to the first node in the linked list, or {@code ENDPOINT} if there are no entries. */
  private transient int firstEntry;

  /** Pointer to the last node in the linked list, or {@code ENDPOINT} if there are no entries. */
  private transient int lastEntry;

  private final boolean accessOrder;

  CompactLinkedHashMap() {

  @Override
  public void close() {}

  public synchronized void clear() {
    list.clear();
  }

  /** Returns a snapshot of the logged records. */
  /*
   * TODO(cpovirk): consider higher-level APIs here (say, assertNoRecordsLogged(),
   * getOnlyRecordLogged(), getAndClearLogRecords()...)
   *
   * TODO(cpovirk): consider renaming this method to reflect that it takes a snapshot (and/or return
   * an ImmutableList)
   */

            return new Iterator<Integer>() {
              @Override
              public void remove() {
                // We should throw here, but we won't!
              }

              @Override
              public Integer next() {
                // We should throw here, but we won't!
                return 0;
              }

              @Override
              public boolean hasNext() {

  Logger get() {
    /*
     * We use double-checked locking. We could the try racy single-check idiom, but that would
     * depend on Logger not contain mutable state.
     *
     * We could use Suppliers.memoizingSupplier here, but I micro-optimized to this implementation
     * to avoid the extra class for the lambda (and maybe more for memoizingSupplier itself) and the
     * indirection.
     *

   */
  @Override
  protected void expectContents(Collection<E> expectedCollection) {
    List<E> expectedList = Helpers.copyToList(expectedCollection);
    // Avoid expectEquals() here to delay reason manufacture until necessary.
    if (getList().size() != expectedList.size()) {
      fail("size mismatch: " + reportContext(expectedList));
    }
    for (int i = 0; i < expectedList.size(); i++) {