for (int i = 0; i < cellList.size(); i++) {
      Cell<R, C, V> cell = cellList.get(i);
      R rowKey = cell.getRowKey();
      C columnKey = cell.getColumnKey();
      // The requireNonNull calls are safe because we construct the indexes with indexMap.
      int rowIndex = requireNonNull(rowKeyToIndex.get(rowKey));
      int columnIndex = requireNonNull(columnKeyToIndex.get(columnKey));

 *       suffice because we our Android users and tests are using the open-source version, which
 *       would no longer have the problematic test. But why bother when we can instead strip it with
 *       a more precisely named annotation?
 *   <li>While a dependency on Android ought to be easy if it's for annotations only, it will

      fail();
    } catch (VerifyException expected) {
      checkMessage(expected);
    }
  }

  @J2ktIncompatible
  @GwtIncompatible // NullPointerTester
  public void testNullPointers() {
    // Don't bother testing: Verify is like Preconditions. See the discussion on that class.
  }

  private static final Object IGNORE_ME =
      new Object() {
        @Override
        public String toString() {

            alternatingKeysAndValues[previousKeyIndex ^ 1] = value;
            continue entries;
          }
        }
        if (outI < i) { // if outI == i don't bother writing the values back where they came from
          alternatingKeysAndValues[outKeyIndex] = key;
          alternatingKeysAndValues[outKeyIndex ^ 1] = value;
        }
        outI++;
      }

  private static final String LOWER = "abcdefghijklmnopqrstuvwxyz";
  private static final String UPPER = "ABCDEFGHIJKLMNOPQRSTUVWXYZ";

  public void testToLowerCase() {
    assertEquals(LOWER, Ascii.toLowerCase(UPPER));
    assertSame(LOWER, Ascii.toLowerCase(LOWER));
    assertEquals(IGNORED, Ascii.toLowerCase(IGNORED));

    verifyTableSize(100, 5, 8);
    verifyTableSize(100, 33, 64);
    verifyTableSize(60, 60, 128);
    verifyTableSize(120, 60, 256);
    // if the table is only double the necessary size, we don't bother resizing it
    verifyTableSize(180, 60, 128);
    // but if it's even bigger than double, we rebuild the table
    verifyTableSize(17, 17, 32);
    verifyTableSize(17, 16, 32);
    verifyTableSize(17, 15, 32);
  }

   * by applying the given {@code AsyncFunction} to the result of the original {@code Future}.
   * Example usage:
   *
   * <pre>{@code
   * FluentFuture<RowKey> rowKeyFuture = FluentFuture.from(indexService.lookUp(query));
   * ListenableFuture<QueryResult> queryFuture =
   *     rowKeyFuture.transformAsync(dataService::readFuture, executor);
   * }</pre>
   *

    return Types.newArrayType(resolvedComponentType);
  }

  private ParameterizedType resolveParameterizedType(ParameterizedType type) {
    Type owner = type.getOwnerType();
    Type resolvedOwner = (owner == null) ? null : resolveType(owner);
    Type resolvedRawType = resolveType(type.getRawType());

    Type[] args = type.getActualTypeArguments();
    Type[] resolvedArgs = resolveTypes(args);

    @Override
    public boolean contains(@CheckForNull Object rowKey, @CheckForNull Object columnKey) {
      synchronized (mutex) {
        return delegate().contains(rowKey, columnKey);
      }
    }

    @Override
    public boolean containsRow(@CheckForNull Object rowKey) {
      synchronized (mutex) {
        return delegate().containsRow(rowKey);
      }
    }

    @Override

    @Override
    public boolean containsRow(Object rowKey) {
      assertTrue(Thread.holdsLock(mutex));
      return delegate.containsRow(rowKey);
    }

    @Override
    public @Nullable V get(Object rowKey, Object columnKey) {
      assertTrue(Thread.holdsLock(mutex));
      return delegate.get(rowKey, columnKey);
    }

    @Override
    public @Nullable V put(R rowKey, C columnKey, V value) {